readout_chain.h

Go to the documentation of this file.

#pragma once
 
#ifndef CHIP_REVISION
#error "Requires CHIP_REVISION"
#endif
 
#define ID(x) x
#define XSTR(x) #x
#define STR(x) XSTR(x)
// clang-format off
#define CONCAT(w, x, y, z) STR(ID(w)ID(/)ID(x)ID(/)ID(v)ID(y)ID(/)ID(z))
#include CONCAT(haldls,vx,CHIP_REVISION,capmem.h)
// clang-format on
#undef ID
#undef XSTR
#undef STR
#undef CONCAT
 
#include "halco/common/typed_array.h"
#include "halco/hicann-dls/vx/readout.h"
#include "halco/hicann-dls/vx/current_dac.h"
#include "haldls/cerealization.h"
#include "haldls/vx/madc.h"
#include "haldls/vx/current_dac.h"
#include "haldls/vx/readout.h"
#include "hate/visibility.h"
#include "lola/vx/cerealization.h"
#include "lola/vx/genpybind.h"
 
#if CHIP_REVISION == 2
#define GENPYBIND_TAG_LOLA_VX_VY GENPYBIND_TAG_LOLA_VX_V2
#define CHIP_REVISION_STR v2
#elif CHIP_REVISION == 3
#define GENPYBIND_TAG_LOLA_VX_VY GENPYBIND_TAG_LOLA_VX_V3
#define CHIP_REVISION_STR v3
#else
#error "Unknown CHIP_REVISION"
#endif
 
namespace lola::vx::CHIP_REVISION_STR GENPYBIND_TAG_LOLA_VX_VY {
#undef GENPYBIND_TAG_LOLA_VX_VY
 
class GENPYBIND(visible) ReadoutChain
{
public:
    typedef halco::hicann_dls::vx::ReadoutChainOnDLS coordinate_type;
    typedef std::false_type has_local_data;
 
    typedef haldls::vx::CHIP_REVISION_STR::CapMemCell::Value AnalogValue GENPYBIND(visible);
    typedef haldls::vx::CHIP_REVISION_STR::CapMemCell::DisableRefresh AnalogDisableRefresh
        GENPYBIND(visible);
    typedef haldls::vx::CHIP_REVISION_STR::CapMemCell::value_type AnalogValueVariant;
 
    ReadoutChain() = default;
 
    typedef halco::common::typed_array<
        haldls::vx::ReadoutSourceSelection::SourceMultiplexer,
        halco::hicann_dls::vx::SourceMultiplexerOnReadoutSourceSelection>
        InputMux GENPYBIND(opaque(false));
 
    struct GENPYBIND(visible) BufferToPadT
    {
        BufferToPadT() SYMBOL_VISIBLE;
 
        bool enable;
 
        AnalogValueVariant amp_i_bias;
 
        bool operator==(BufferToPadT const& other) const SYMBOL_VISIBLE;
        bool operator!=(BufferToPadT const& other) const SYMBOL_VISIBLE;
        GENPYBIND(stringstream)
        friend std::ostream& operator<<(std::ostream& os, BufferToPadT const& config)
            SYMBOL_VISIBLE;
    };
 
    typedef halco::common::
        typed_array<BufferToPadT, halco::hicann_dls::vx::SourceMultiplexerOnReadoutSourceSelection>
            BufferToPad GENPYBIND(opaque(false));
 
    struct GENPYBIND(visible) DynamicMux
    {
        DynamicMux() = default;
 
        typedef haldls::vx::MADCConfig::ActiveMuxInputSelectLength InputSelectLength
            GENPYBIND(visible);
        typedef haldls::vx::MADCConfig::input_selection_type InputSelect GENPYBIND(visible);
        bool enable_amplifiers{true};
 
        InputSelect initially_selected_input{};
 
        InputSelectLength input_select_length{};
 
        AnalogValueVariant i_bias{AnalogValue{500}};
 
        bool operator==(DynamicMux const& other) const SYMBOL_VISIBLE;
        bool operator!=(DynamicMux const& other) const SYMBOL_VISIBLE;
        GENPYBIND(stringstream)
        friend std::ostream& operator<<(std::ostream& os, DynamicMux const& config) SYMBOL_VISIBLE;
    };
 
    typedef haldls::vx::MADCConfig::hemisphere_type HemisphereType GENPYBIND(visible);
    typedef haldls::vx::MADCConfig::synapse_target_type SynapseTargetType GENPYBIND(visible);
 
    struct GENPYBIND(visible) PseudoDifferentialConverter
    {
        PseudoDifferentialConverter() = default;
 
        HemisphereType enable_reference{{false, false}};
 
        AnalogValueVariant v_ref{AnalogValue{400}};
 
        AnalogValueVariant buffer_bias{AnalogValue{0}};
 
        bool operator==(PseudoDifferentialConverter const& other) const SYMBOL_VISIBLE;
        bool operator!=(PseudoDifferentialConverter const& other) const SYMBOL_VISIBLE;
        GENPYBIND(stringstream)
        friend std::ostream& operator<<(std::ostream& os, PseudoDifferentialConverter const& config)
            SYMBOL_VISIBLE;
    };
 
    struct GENPYBIND(visible) MADCInputCrossbar
    {
        MADCInputCrossbar() SYMBOL_VISIBLE;
 
        bool connect_source_measure_unit;
 
        bool connect_dynamic_mux;
 
        bool connect_pad_mux;
 
        bool connect_madc_preamp;
 
 
        bool operator==(MADCInputCrossbar const& other) const SYMBOL_VISIBLE;
        bool operator!=(MADCInputCrossbar const& other) const SYMBOL_VISIBLE;
        GENPYBIND(stringstream)
        friend std::ostream& operator<<(std::ostream& os, MADCInputCrossbar const& config)
            SYMBOL_VISIBLE;
    };
 
 
    typedef haldls::vx::MADCConfig::SamplingWindowTiming SamplingWindowTiming GENPYBIND(visible);
 
    struct GENPYBIND(visible) MADCPreamp
    {
        MADCPreamp() = default;
 
        typedef haldls::vx::MADCConfig::PreampGainCapacitorSize GainCapacitorSize
            GENPYBIND(visible);
 
        GainCapacitorSize gain_cap_size{};
 
        SamplingWindowTiming sampling_window_start{3};
 
        SamplingWindowTiming sampling_window_end{8};
 
        AnalogValueVariant v_ref{AnalogValue{400}};
 
        AnalogValueVariant i_bias{AnalogValue{500}};
 
        bool operator==(MADCPreamp const& other) const SYMBOL_VISIBLE;
        bool operator!=(MADCPreamp const& other) const SYMBOL_VISIBLE;
        GENPYBIND(stringstream)
        friend std::ostream& operator<<(std::ostream& os, MADCPreamp const& config) SYMBOL_VISIBLE;
    };
 
    struct GENPYBIND(visible) MADCDebugCrossbar
    {
        MADCDebugCrossbar() SYMBOL_VISIBLE;
 
        typedef haldls::vx::MADCConfig::PreampGainCapacitorSize GainCapacitorSize
            GENPYBIND(visible);
 
        bool connect_preamp_to_madc;
 
        bool connect_pads_to_madc;
 
        bool connect_preamp_to_pads;
 
        bool operator==(MADCDebugCrossbar const& other) const SYMBOL_VISIBLE;
        bool operator!=(MADCDebugCrossbar const& other) const SYMBOL_VISIBLE;
        GENPYBIND(stringstream)
        friend std::ostream& operator<<(std::ostream& os, MADCDebugCrossbar const& config)
            SYMBOL_VISIBLE;
    };
 
    struct GENPYBIND(visible) MADC
    {
        MADC() = default;
 
        typedef haldls::vx::MADCConfig::SampleDurationAdjust SampleDurationAdjust
            GENPYBIND(visible);
        typedef haldls::vx::MADCConfig::SARResetWait SARResetWait GENPYBIND(visible);
        typedef haldls::vx::MADCConfig::SARResetLength SARResetLength GENPYBIND(visible);
        typedef haldls::vx::MADCConfig::PowerupWaitValue PowerupWaitValue GENPYBIND(visible);
        typedef haldls::vx::MADCConfig::CalibrationWaitValue CalibrationWaitValue
            GENPYBIND(visible);
        typedef haldls::vx::MADCConfig::NumberOfSamples NumberOfSamples GENPYBIND(visible);
        typedef haldls::vx::MADCConfig::MADCClockScaleValue ClockScaleValue GENPYBIND(visible);
        typedef haldls::vx::MADCConfig::ConversionCyclesOffset ConversionCyclesOffset
            GENPYBIND(visible);
 
        SampleDurationAdjust sample_duration_adjust{SampleDurationAdjust()};
 
        bool enable_sar_reset_on_fall{false};
        SARResetWait sar_reset_wait{};
        SARResetLength sar_reset_length{};
 
        PowerupWaitValue powerup_wait_value{};
 
        ConversionCyclesOffset conversion_cycles_offset{};
 
        bool enable_calibration{false};
 
        CalibrationWaitValue calibration_wait_value{};
 
        NumberOfSamples number_of_samples{};
 
        /*
         * Let the MADC sample on the positive clock edge.
         */
        bool sample_on_positive_edge{true};
 
        /*
         * Enable dummy data generation.
         * If enabled, the MADC will stream out the last 10 bit of the sample
         * counter value as a test pattern (sawtooth).
         */
        bool enable_dummy_data{false};
 
        bool enable_madc_clock_scaling{false};
 
        ClockScaleValue clock_scale_value{};
 
        AnalogValueVariant in_500na{AnalogValue{500}};
 
        bool operator==(MADC const& other) const SYMBOL_VISIBLE;
        bool operator!=(MADC const& other) const SYMBOL_VISIBLE;
        GENPYBIND(stringstream)
        friend std::ostream& operator<<(std::ostream& os, MADC const& config) SYMBOL_VISIBLE;
    };
 
    typedef halco::common::typed_array<
        haldls::vx::PadMultiplexerConfig,
        halco::hicann_dls::vx::PadMultiplexerConfigOnDLS>
        PadMux GENPYBIND(opaque(false));
 
    struct GENPYBIND(visible) SourceMeasureUnit
    {
        SourceMeasureUnit() = default;
 
        SamplingWindowTiming sampling_window_start{9};
 
        SamplingWindowTiming sampling_window_end{14};
 
        HemisphereType connect_neuron_stimulus{{false, false}};
 
        SynapseTargetType connect_synapse_debug{{false, false}};
 
        AnalogValueVariant test_voltage{AnalogValue{400}};
 
        AnalogValueVariant buffer_i_bias{};
 
        AnalogValueVariant amp_v_ref{AnalogValue{400}};
 
        AnalogValueVariant amp_i_bias{};
 
        bool operator==(SourceMeasureUnit const& other) const SYMBOL_VISIBLE;
        bool operator!=(SourceMeasureUnit const& other) const SYMBOL_VISIBLE;
        GENPYBIND(stringstream)
        friend std::ostream& operator<<(std::ostream& os, SourceMeasureUnit const& config)
            SYMBOL_VISIBLE;
    };
 
    struct GENPYBIND(visible) CurrentDAC
    {
        typedef haldls::vx::CurrentDAC::Current Current GENPYBIND(visible);
        typedef haldls::vx::CurrentDAC::Sign Sign GENPYBIND(visible);
 
        CurrentDAC() SYMBOL_VISIBLE;
 
        bool enable_current;
 
        Current current;
 
        Sign sign;
 
        HemisphereType connect_neuron_stimulus;
 
        SynapseTargetType connect_synapse_debug;
 
        AnalogValueVariant i_bias;
 
        AnalogValueVariant i_bias_casc;
 
        bool operator==(CurrentDAC const& other) const SYMBOL_VISIBLE;
        bool operator!=(CurrentDAC const& other) const SYMBOL_VISIBLE;
        GENPYBIND(stringstream)
        friend std::ostream& operator<<(std::ostream& os, CurrentDAC const& config) SYMBOL_VISIBLE;
    };
 
    InputMux input_mux;
    BufferToPad buffer_to_pad;
    DynamicMux dynamic_mux;
    PseudoDifferentialConverter pseudo_diff_converter;
    MADCInputCrossbar madc_input_crossbar;
    MADCPreamp madc_preamp;
    MADCDebugCrossbar madc_debug_crossbar;
    MADC madc;
    PadMux pad_mux;
    SourceMeasureUnit source_measure_unit;
    CurrentDAC current_dac;
 
    bool operator==(ReadoutChain const& other) const SYMBOL_VISIBLE;
    bool operator!=(ReadoutChain const& other) const SYMBOL_VISIBLE;
 
    GENPYBIND(stringstream)
    friend std::ostream& operator<<(std::ostream& os, ReadoutChain const& config) SYMBOL_VISIBLE;
 
private:
    friend haldls::vx::detail::VisitPreorderImpl<ReadoutChain>;
};
 
std::ostream& operator<<(std::ostream& os, ReadoutChain::InputMux const& config) SYMBOL_VISIBLE;
std::ostream& operator<<(std::ostream& os, ReadoutChain::BufferToPad const& config) SYMBOL_VISIBLE;
std::ostream& operator<<(std::ostream& os, ReadoutChain::PadMux const& config) SYMBOL_VISIBLE;
 
 
} // lola::vx::CHIP_REVISION_STR
 
#include "lola/vx/readout_chain.tcc"