HALDLS
i2c.h
Go to the documentation of this file.
1 #pragma once
2 #include <array>
3 #include <iosfwd>
4 #include <limits>
5 
6 #include "fisch/vx/constants.h"
7 #include "fisch/vx/word_access/type/i2c.h"
8 #include "halco/common/geometry.h"
9 #include "halco/common/iter_all.h"
10 #include "halco/common/typed_array.h"
11 #include "halco/hicann-dls/vx/i2c.h"
12 #include "halco/hicann-dls/vx/ultra96.h"
13 #include "halco/hicann-dls/vx/xboard.h"
14 #include "haldls/cerealization.h"
15 #include "haldls/vx/genpybind.h"
16 #include "haldls/vx/traits.h"
17 #include "hate/math.h"
18 #include "hate/visibility.h"
19 #include "hxcomm/vx/target.h"
20 
21 namespace halco::hicann_dls::vx {} // namespace halco::hicann_dls::vx
22 
23 namespace haldls {
24 namespace vx GENPYBIND_TAG_HALDLS_VX {
25 
26 class GENPYBIND(visible) INA219Config
27 {
28 public:
29  typedef halco::hicann_dls::vx::INA219ConfigOnBoard coordinate_type;
30  typedef std::true_type is_leaf_node;
31  constexpr static auto unsupported_read_targets GENPYBIND(hidden) = {
32  hxcomm::vx::Target::simulation};
33 
35  enum class ADCMode
36  {
37  bits9 = 0,
38  bits10 = 1,
39  bits11 = 2,
40  bits12 = 3,
41  bits12_samples1 = 4,
42  bits12_samples2 = 5,
43  bits12_samples4 = 6,
44  bits12_samples8 = 7,
45  bits12_samples16 = 8,
46  bits12_samples32 = 9,
47  bits12_samples64 = 10,
48  bits12_samples128 = 11
49  };
50 
52  INA219Config() SYMBOL_VISIBLE;
53 
58  GENPYBIND(getter_for(bus_adc_mode))
59  ADCMode get_bus_adc_mode() const SYMBOL_VISIBLE;
60 
65  GENPYBIND(setter_for(bus_adc_mode))
66  void set_bus_adc_mode(ADCMode value) SYMBOL_VISIBLE;
67 
72  GENPYBIND(getter_for(shunt_adc_mode))
73  ADCMode get_shunt_adc_mode() const SYMBOL_VISIBLE;
74 
79  GENPYBIND(setter_for(shunt_adc_mode))
80  void set_shunt_adc_mode(ADCMode value) SYMBOL_VISIBLE;
81 
82  bool operator==(INA219Config const& other) const SYMBOL_VISIBLE;
83  bool operator!=(INA219Config const& other) const SYMBOL_VISIBLE;
84 
85  GENPYBIND(stringstream)
86  friend std::ostream& operator<<(std::ostream& os, INA219Config const& config) SYMBOL_VISIBLE;
87 
88  static size_t constexpr config_size_in_words GENPYBIND(hidden) = 1;
89  static std::array<halco::hicann_dls::vx::I2CINA219RwRegisterOnBoard, config_size_in_words>
90  addresses(coordinate_type const& coord) SYMBOL_VISIBLE GENPYBIND(hidden);
91  std::array<fisch::vx::word_access_type::I2CINA219RwRegister, config_size_in_words> encode()
92  const SYMBOL_VISIBLE GENPYBIND(hidden);
93  void decode(
94  std::array<fisch::vx::word_access_type::I2CINA219RwRegister, config_size_in_words> const&
95  data) SYMBOL_VISIBLE GENPYBIND(hidden);
96 
97 private:
98  friend class cereal::access;
99  template <typename Archive>
100  void serialize(Archive& ar, std::uint32_t const version) SYMBOL_VISIBLE;
101 
102  ADCMode m_bus_adc_mode;
103  ADCMode m_shunt_adc_mode;
104 };
105 
106 std::ostream& operator<<(std::ostream& os, INA219Config::ADCMode const& mode) SYMBOL_VISIBLE;
107 
108 EXTERN_INSTANTIATE_CEREAL_SERIALIZE(INA219Config)
109 
110 namespace detail {
111 
112 template <>
113 struct BackendContainerTrait<INA219Config>
114  : public BackendContainerBase<INA219Config, fisch::vx::word_access_type::I2CINA219RwRegister>
115 {};
116 
117 } // namespace detail
118 
119 
120 class GENPYBIND(visible) INA219Status
121 {
122 public:
123  typedef halco::hicann_dls::vx::INA219StatusOnBoard coordinate_type;
124  typedef std::true_type is_leaf_node;
125  constexpr static auto unsupported_read_targets GENPYBIND(hidden) = {
126  hxcomm::vx::Target::simulation};
127 
131  struct GENPYBIND(inline_base("*")) BusVoltage
132  : public halco::common::detail::RantWrapper<BusVoltage, uint_fast16_t, 4000, 0>
133  {
134  constexpr explicit BusVoltage(uintmax_t const val = 0) GENPYBIND(implicit_conversion) :
135  rant_t(val)
136  {}
137 
141  float toUncalibratedVoltage() const SYMBOL_VISIBLE;
142  };
143 
147  struct GENPYBIND(inline_base("*")) ShuntVoltage
148  : public halco::common::detail::RantWrapper<ShuntVoltage, int16_t, 4000, -4000>
149  {
150  constexpr explicit ShuntVoltage(intmax_t const val = 0) GENPYBIND(implicit_conversion) :
151  rant_t(val)
152  {}
153 
157  float toUncalibratedVoltage() const SYMBOL_VISIBLE;
158  };
159 
163  struct GENPYBIND(visible) UncalibratedPower
164  {
168  float uncalibrated_bus_voltage;
169 
173  float uncalibrated_shunt_voltage;
174 
175  /*
176  * Shunt resistance [Ohm].
177  */
178  float shunt_resistance = 0.027;
179 
180  float calculate() const SYMBOL_VISIBLE;
181 
182  GENPYBIND(stringstream)
183  friend std::ostream& operator<<(std::ostream& os, UncalibratedPower const& data)
184  SYMBOL_VISIBLE;
185  };
186 
188  INA219Status() SYMBOL_VISIBLE;
189 
194  GENPYBIND(getter_for(bus_voltage))
195  BusVoltage get_bus_voltage() const SYMBOL_VISIBLE;
196 
201  GENPYBIND(setter_for(bus_voltage))
202  void set_bus_voltage(BusVoltage value) SYMBOL_VISIBLE;
203 
208  GENPYBIND(getter_for(bus_voltage_overflow))
209  bool get_bus_voltage_overflow() const SYMBOL_VISIBLE;
210 
215  GENPYBIND(setter_for(bus_voltage_overflow))
216  void set_bus_voltage_overflow(bool value) SYMBOL_VISIBLE;
217 
222  GENPYBIND(getter_for(shunt_voltage))
223  ShuntVoltage get_shunt_voltage() const SYMBOL_VISIBLE;
224 
229  GENPYBIND(setter_for(shunt_voltage))
230  void set_shunt_voltage(ShuntVoltage value) SYMBOL_VISIBLE;
231 
237  UncalibratedPower toUncalibratedPower() const SYMBOL_VISIBLE;
238 
239  bool operator==(INA219Status const& other) const SYMBOL_VISIBLE;
240  bool operator!=(INA219Status const& other) const SYMBOL_VISIBLE;
241 
242  GENPYBIND(stringstream)
243  friend std::ostream& operator<<(std::ostream& os, INA219Status const& config) SYMBOL_VISIBLE;
244 
245  static size_t constexpr write_config_size_in_words GENPYBIND(hidden) = 0;
246  static size_t constexpr read_config_size_in_words GENPYBIND(hidden) = 2;
247  static std::array<halco::hicann_dls::vx::I2CINA219RoRegisterOnBoard, write_config_size_in_words>
248  write_addresses(coordinate_type const& coord) SYMBOL_VISIBLE GENPYBIND(hidden);
249  static std::array<halco::hicann_dls::vx::I2CINA219RoRegisterOnBoard, read_config_size_in_words>
250  read_addresses(coordinate_type const& coord) SYMBOL_VISIBLE GENPYBIND(hidden);
251  std::array<fisch::vx::word_access_type::I2CINA219RoRegister, write_config_size_in_words>
252  encode() const SYMBOL_VISIBLE GENPYBIND(hidden);
253  void decode(std::array<
254  fisch::vx::word_access_type::I2CINA219RoRegister,
255  read_config_size_in_words> const& data) SYMBOL_VISIBLE GENPYBIND(hidden);
256 
257 private:
258  friend class cereal::access;
259  template <typename Archive>
260  void serialize(Archive& ar, std::uint32_t const version) SYMBOL_VISIBLE;
261 
262  BusVoltage m_bus_voltage;
263  bool m_bus_voltage_overflow;
264  ShuntVoltage m_shunt_voltage;
265 };
266 
267 EXTERN_INSTANTIATE_CEREAL_SERIALIZE(INA219Status)
268 
269 namespace detail {
270 
271 template <>
272 struct BackendContainerTrait<INA219Status>
273  : public BackendContainerBase<INA219Status, fisch::vx::word_access_type::I2CINA219RoRegister>
274 {};
275 
276 } // namespace detail
277 
278 
279 class GENPYBIND(visible) TCA9554Inputs
280 {
281 public:
282  typedef halco::hicann_dls::vx::TCA9554InputsOnBoard coordinate_type;
283  typedef std::true_type is_leaf_node;
284  constexpr static auto unsupported_read_targets GENPYBIND(hidden) = {
285  hxcomm::vx::Target::simulation};
286 
287  typedef GENPYBIND(opaque) halco::common::
288  typed_array<bool, halco::hicann_dls::vx::TCA9554ChannelOnBoard> ChannelsBooleanArray;
289 
290  /* Default constructor */
291  TCA9554Inputs() SYMBOL_VISIBLE;
292 
297  GENPYBIND(getter_for(channel_input), return_value_policy(reference_internal))
298  ChannelsBooleanArray const& get_channel_input() const SYMBOL_VISIBLE;
299 
304  GENPYBIND(setter_for(channel_input))
305  void set_channel_input(ChannelsBooleanArray const& value) SYMBOL_VISIBLE;
306 
307  bool operator==(TCA9554Inputs const& other) const SYMBOL_VISIBLE;
308  bool operator!=(TCA9554Inputs const& other) const SYMBOL_VISIBLE;
309 
310  GENPYBIND(stringstream)
311  friend std::ostream& operator<<(std::ostream& os, TCA9554Inputs const& config) SYMBOL_VISIBLE;
312 
313  static size_t constexpr config_size_in_words GENPYBIND(hidden) = 1;
314  static std::array<halco::hicann_dls::vx::I2CTCA9554RoRegisterOnBoard, config_size_in_words>
315  addresses(coordinate_type const& coord) SYMBOL_VISIBLE GENPYBIND(hidden);
316  std::array<fisch::vx::word_access_type::I2CTCA9554RoRegister, config_size_in_words> encode()
317  const SYMBOL_VISIBLE GENPYBIND(hidden);
318  void decode(
319  std::array<fisch::vx::word_access_type::I2CTCA9554RoRegister, config_size_in_words> const&
320  data) SYMBOL_VISIBLE GENPYBIND(hidden);
321 
322 private:
323  friend class cereal::access;
324  template <typename Archive>
325  void serialize(Archive& ar, std::uint32_t const version) SYMBOL_VISIBLE;
326 
327  ChannelsBooleanArray m_input;
328 };
329 
330 EXTERN_INSTANTIATE_CEREAL_SERIALIZE(TCA9554Inputs)
331 
332 namespace detail {
333 
334 template <>
335 struct BackendContainerTrait<TCA9554Inputs>
336  : public BackendContainerBase<TCA9554Inputs, fisch::vx::word_access_type::I2CTCA9554RoRegister>
337 {};
338 
339 } // namespace detail
340 
341 class GENPYBIND(visible) TCA9554Config
342 {
343 public:
344  typedef halco::hicann_dls::vx::TCA9554ConfigOnBoard coordinate_type;
345  typedef std::true_type is_leaf_node;
346  constexpr static auto unsupported_read_targets GENPYBIND(hidden) = {
347  hxcomm::vx::Target::simulation};
348 
349  enum class ChannelPolarity : bool
350  {
351  normal = false,
352  inverted = true
353  };
354 
355  enum class ChannelMode : bool
356  {
357  output = false,
358  input = true
359  };
360 
361  typedef GENPYBIND(opaque(false)) halco::common::
362  typed_array<bool, halco::hicann_dls::vx::TCA9554ChannelOnBoard> ChannelsBooleanArray;
363  typedef GENPYBIND(opaque) halco::common::typed_array<
364  ChannelPolarity,
365  halco::hicann_dls::vx::TCA9554ChannelOnBoard> ChannelsPolarityArray;
366  typedef GENPYBIND(opaque) halco::common::
367  typed_array<ChannelMode, halco::hicann_dls::vx::TCA9554ChannelOnBoard> ChannelsModeArray;
368 
370  TCA9554Config() SYMBOL_VISIBLE;
371 
376  GENPYBIND(getter_for(channel_output), return_value_policy(reference_internal))
377  ChannelsBooleanArray const& get_channel_output() const SYMBOL_VISIBLE;
378 
383  GENPYBIND(setter_for(channel_output))
384  void set_channel_output(ChannelsBooleanArray const& value) SYMBOL_VISIBLE;
385 
390  GENPYBIND(getter_for(channel_polarity), return_value_policy(reference_internal))
391  ChannelsPolarityArray const& get_channel_polarity() const SYMBOL_VISIBLE;
392 
397  GENPYBIND(setter_for(channel_polarity))
398  void set_channel_polarity(ChannelsPolarityArray const& value) SYMBOL_VISIBLE;
399 
404  GENPYBIND(getter_for(channel_mode), return_value_policy(reference_internal))
405  ChannelsModeArray const& get_channel_mode() const SYMBOL_VISIBLE;
406 
411  GENPYBIND(setter_for(channel_mode))
412  void set_channel_mode(ChannelsModeArray const& value) SYMBOL_VISIBLE;
413 
414  bool operator==(TCA9554Config const& other) const SYMBOL_VISIBLE;
415  bool operator!=(TCA9554Config const& other) const SYMBOL_VISIBLE;
416 
417  GENPYBIND(stringstream)
418  friend std::ostream& operator<<(std::ostream& os, TCA9554Config const& config) SYMBOL_VISIBLE;
419 
420  static size_t constexpr config_size_in_words GENPYBIND(hidden) = 3;
421  static std::array<halco::hicann_dls::vx::I2CTCA9554RwRegisterOnBoard, config_size_in_words>
422  addresses(coordinate_type const& coord) SYMBOL_VISIBLE GENPYBIND(hidden);
423  std::array<fisch::vx::word_access_type::I2CTCA9554RwRegister, config_size_in_words> encode()
424  const SYMBOL_VISIBLE GENPYBIND(hidden);
425  void decode(
426  std::array<fisch::vx::word_access_type::I2CTCA9554RwRegister, config_size_in_words> const&
427  data) SYMBOL_VISIBLE GENPYBIND(hidden);
428 
429 private:
430  friend class cereal::access;
431  template <typename Archive>
432  void serialize(Archive& ar, std::uint32_t const version) SYMBOL_VISIBLE;
433 
434  ChannelsBooleanArray m_output;
435  ChannelsPolarityArray m_polarity;
436  ChannelsModeArray m_mode;
437 };
438 
439 EXTERN_INSTANTIATE_CEREAL_SERIALIZE(TCA9554Config)
440 
441 namespace detail {
442 
443 template <>
444 struct BackendContainerTrait<TCA9554Config>
445  : public BackendContainerBase<TCA9554Config, fisch::vx::word_access_type::I2CTCA9554RwRegister>
446 {};
447 
448 } // namespace detail
449 
450 
451 class GENPYBIND(visible) AD5252ChannelConfig
452 {
453 public:
454  typedef halco::hicann_dls::vx::AD5252ChannelConfigOnBoard coordinate_type;
455  typedef std::true_type is_leaf_node;
456  constexpr static auto unsupported_read_targets GENPYBIND(hidden) = {
457  hxcomm::vx::Target::simulation};
458 
459  struct GENPYBIND(inline_base("*")) WiperSetting
460  : public halco::common::detail::RantWrapper<
461  WiperSetting,
462  uint_fast16_t,
463  std::numeric_limits<uint8_t>::max(),
464  std::numeric_limits<uint8_t>::min()>
465  {
466  constexpr explicit WiperSetting(uintmax_t const val = 0x90) GENPYBIND(implicit_conversion) :
467  rant_t(val)
468  {}
469  };
470 
472  AD5252ChannelConfig() SYMBOL_VISIBLE;
473 
478  GENPYBIND(getter_for(value))
479  WiperSetting get_value() const SYMBOL_VISIBLE;
480 
485  GENPYBIND(setter_for(value))
486  void set_value(WiperSetting value) SYMBOL_VISIBLE;
487 
488  bool operator==(AD5252ChannelConfig const& other) const SYMBOL_VISIBLE;
489  bool operator!=(AD5252ChannelConfig const& other) const SYMBOL_VISIBLE;
490 
491  GENPYBIND(stringstream)
492  friend std::ostream& operator<<(std::ostream& os, AD5252ChannelConfig const& config)
493  SYMBOL_VISIBLE;
494 
495  static size_t constexpr config_size_in_words GENPYBIND(hidden) = 1;
496  static std::array<halco::hicann_dls::vx::I2CAD5252RwRegisterOnBoard, config_size_in_words>
497  addresses(coordinate_type const& coord) SYMBOL_VISIBLE GENPYBIND(hidden);
498  std::array<fisch::vx::word_access_type::I2CAD5252RwRegister, config_size_in_words> encode()
499  const SYMBOL_VISIBLE GENPYBIND(hidden);
500  void decode(
501  std::array<fisch::vx::word_access_type::I2CAD5252RwRegister, config_size_in_words> const&
502  data) SYMBOL_VISIBLE GENPYBIND(hidden);
503 
504 private:
505  friend class cereal::access;
506  template <typename Archive>
507  void serialize(Archive& ar, std::uint32_t const version) SYMBOL_VISIBLE;
508 
509  WiperSetting m_value;
510 };
511 
512 EXTERN_INSTANTIATE_CEREAL_SERIALIZE(AD5252ChannelConfig)
513 
514 namespace detail {
515 
516 template <>
517 struct BackendContainerTrait<AD5252ChannelConfig>
518  : public BackendContainerBase<
519  AD5252ChannelConfig,
520  fisch::vx::word_access_type::I2CAD5252RwRegister>
521 {};
522 
523 } // namespace detail
524 
525 
526 class GENPYBIND(visible) AD5252ChannelConfigPersistent
527 {
528 public:
529  typedef halco::hicann_dls::vx::AD5252ChannelConfigPersistentOnBoard coordinate_type;
530  typedef std::true_type is_leaf_node;
531  constexpr static auto unsupported_read_targets GENPYBIND(hidden) = {
532  hxcomm::vx::Target::simulation};
533 
534  struct GENPYBIND(inline_base("*")) WiperSetting
535  : public halco::common::detail::RantWrapper<
536  WiperSetting,
537  uint_fast16_t,
538  std::numeric_limits<uint8_t>::max(),
539  std::numeric_limits<uint8_t>::min()>
540  {
541  constexpr explicit WiperSetting(uintmax_t const val = 0x90) GENPYBIND(implicit_conversion) :
542  rant_t(val)
543  {}
544  };
545 
546 
548  AD5252ChannelConfigPersistent() SYMBOL_VISIBLE;
549 
554  GENPYBIND(getter_for(value))
555  WiperSetting get_value() const SYMBOL_VISIBLE;
556 
561  GENPYBIND(setter_for(value))
562  void set_value(WiperSetting value) SYMBOL_VISIBLE;
563 
564  bool operator==(AD5252ChannelConfigPersistent const& other) const SYMBOL_VISIBLE;
565  bool operator!=(AD5252ChannelConfigPersistent const& other) const SYMBOL_VISIBLE;
566 
567  GENPYBIND(stringstream)
568  friend std::ostream& operator<<(std::ostream& os, AD5252ChannelConfigPersistent const& config)
569  SYMBOL_VISIBLE;
570 
571  static size_t constexpr config_size_in_words GENPYBIND(hidden) = 1;
572  static std::array<halco::hicann_dls::vx::I2CAD5252RwRegisterOnBoard, config_size_in_words>
573  addresses(coordinate_type const& coord) SYMBOL_VISIBLE GENPYBIND(hidden);
574  std::array<fisch::vx::word_access_type::I2CAD5252RwRegister, config_size_in_words> encode()
575  const SYMBOL_VISIBLE GENPYBIND(hidden);
576  void decode(
577  std::array<fisch::vx::word_access_type::I2CAD5252RwRegister, config_size_in_words> const&
578  data) SYMBOL_VISIBLE GENPYBIND(hidden);
579 
580 private:
581  friend class cereal::access;
582  template <typename Archive>
583  void serialize(Archive& ar, std::uint32_t const version) SYMBOL_VISIBLE;
584 
585  WiperSetting m_value;
586 };
587 
588 EXTERN_INSTANTIATE_CEREAL_SERIALIZE(AD5252ChannelConfigPersistent)
589 
590 namespace detail {
591 
592 template <>
593 struct BackendContainerTrait<AD5252ChannelConfigPersistent>
594  : public BackendContainerBase<
595  AD5252ChannelConfigPersistent,
596  fisch::vx::word_access_type::I2CAD5252RwRegister>
597 {};
598 
599 } // namespace detail
600 
601 
602 class GENPYBIND(visible) DAC6573ChannelConfig
603 {
604 public:
605  typedef halco::hicann_dls::vx::DAC6573ChannelOnBoard coordinate_type;
606  typedef std::true_type is_leaf_node;
607  constexpr static auto unsupported_read_targets GENPYBIND(hidden) = {
608  hxcomm::vx::Target::simulation};
609 
610  struct GENPYBIND(inline_base("*")) Value
611  : public halco::common::detail::RantWrapper<
612  Value,
613  uint_fast32_t,
614  fisch::vx::dac6573_value_max,
615  fisch::vx::dac_value_min>
616  {
617  constexpr explicit Value(uintmax_t const val = 0) GENPYBIND(implicit_conversion) :
618  rant_t(val)
619  {}
620  };
621 
623  DAC6573ChannelConfig(Value const& value = Value()) : m_value(value) {}
624 
629  GENPYBIND(getter_for(value))
630  Value get_value() const SYMBOL_VISIBLE;
631 
636  GENPYBIND(setter_for(value))
637  void set_value(Value value) SYMBOL_VISIBLE;
638 
639  bool operator==(DAC6573ChannelConfig const& other) const SYMBOL_VISIBLE;
640  bool operator!=(DAC6573ChannelConfig const& other) const SYMBOL_VISIBLE;
641 
642  GENPYBIND(stringstream)
643  friend std::ostream& operator<<(std::ostream& os, DAC6573ChannelConfig const& config)
644  SYMBOL_VISIBLE;
645 
646  static size_t constexpr config_size_in_words GENPYBIND(hidden) = 1;
647  static std::array<halco::hicann_dls::vx::I2CDAC6573RwRegisterOnBoard, config_size_in_words>
648  addresses(coordinate_type const& coord) SYMBOL_VISIBLE GENPYBIND(hidden);
649  std::array<fisch::vx::word_access_type::I2CDAC6573RwRegister, config_size_in_words> encode()
650  const SYMBOL_VISIBLE GENPYBIND(hidden);
651  void decode(
652  std::array<fisch::vx::word_access_type::I2CDAC6573RwRegister, config_size_in_words> const&
653  data) SYMBOL_VISIBLE GENPYBIND(hidden);
654 
655 private:
656  friend class cereal::access;
657  template <typename Archive>
658  void serialize(Archive& ar, std::uint32_t const version) SYMBOL_VISIBLE;
659 
660  Value m_value;
661 };
662 
663 EXTERN_INSTANTIATE_CEREAL_SERIALIZE(DAC6573ChannelConfig)
664 
665 namespace detail {
666 
667 template <>
668 struct BackendContainerTrait<DAC6573ChannelConfig>
669  : public BackendContainerBase<
670  DAC6573ChannelConfig,
671  fisch::vx::word_access_type::I2CDAC6573RwRegister>
672 {};
673 
674 } // namespace detail
675 
676 } // namespace vx
677 } // namespace haldls
678 
679 namespace std {
680 
681 HALCO_GEOMETRY_HASH_CLASS(haldls::vx::DAC6573ChannelConfig::Value)
682 
683 }
EXTERN_INSTANTIATE_CEREAL_SERIALIZE
#define EXTERN_INSTANTIATE_CEREAL_SERIALIZE(CLASS_NAME)
Definition: cerealization.h:75
haldls::vx::INA219Config::ADCMode
ADCMode
ADC resolution and number of samples.
Definition: i2c.h:36
haldls::vx::INA219Config::coordinate_type
halco::hicann_dls::vx::INA219ConfigOnBoard coordinate_type
Definition: i2c.h:29
haldls::vx::INA219Config::INA219Config
INA219Config() SYMBOL_VISIBLE
Default constructor.
haldls::vx::INA219Config::is_leaf_node
std::true_type is_leaf_node
Definition: i2c.h:30
haldls::vx::INA219Status::is_leaf_node
std::true_type is_leaf_node
Definition: i2c.h:124
haldls::vx::INA219Status::coordinate_type
halco::hicann_dls::vx::INA219StatusOnBoard coordinate_type
Definition: i2c.h:123
GENPYBIND_TAG_HALDLS_VX
#define GENPYBIND_TAG_HALDLS_VX
Definition: genpybind.h:4
halco::hicann_dls::vx
Definition: arq.h:13
halco
Definition: arq.h:13
haldls::vx::detail::BackendContainerBase
Backend container trait base.
Definition: traits.h:77