init_generator.h

Go to the documentation of this file.

#pragma once
#include "hate/visibility.h"
#include "stadls/vx/v2/playback_generator.h"
#include "stadls/vx/v2/playback_program_builder.h"
 
namespace stadls::vx::v2 GENPYBIND_TAG_STADLS_VX_V2 {
 
namespace detail {
 
class GENPYBIND(expose_as(_InitGenerator)) InitGenerator
{
public:
    InitGenerator() SYMBOL_VISIBLE;
 
    typedef v2::PlaybackProgramBuilder Builder;
 
    haldls::vx::InstructionTimeoutConfig instruction_timeout;
 
    haldls::vx::ShiftRegister shift_register;
 
    lola::vx::DACControlBlock dac_control_block;
 
    lola::vx::DACChannelBlock dac_channel_block;
 
    bool enable_xboard;
 
    haldls::vx::JTAGClockScaler jtag_clock_scaler;
 
    haldls::vx::v2::PLLClockOutputBlock pll_clock_output_block;
 
    typedef halco::common::typed_array<haldls::vx::ADPLL, halco::hicann_dls::vx::v2::ADPLLOnDLS>
        adplls_type GENPYBIND(opaque(false));
    adplls_type adplls;
 
    struct GENPYBIND(visible) HighspeedLink
    {
        HighspeedLink() SYMBOL_VISIBLE;
 
        haldls::vx::CommonPhyConfigFPGA common_phy_config_fpga;
 
        haldls::vx::CommonPhyConfigChip common_phy_config_chip;
 
        typedef halco::common::
            typed_array<haldls::vx::PhyConfigFPGA, halco::hicann_dls::vx::v2::PhyConfigFPGAOnDLS>
                phy_configs_fpga_type GENPYBIND(opaque(false));
        phy_configs_fpga_type phy_configs_fpga;
 
        typedef halco::common::
            typed_array<haldls::vx::PhyConfigChip, halco::hicann_dls::vx::v2::PhyConfigChipOnDLS>
                phy_configs_chip_type GENPYBIND(opaque(false));
        phy_configs_chip_type phy_configs_chip;
 
        haldls::vx::SystimeSyncBase systime_sync_base;
 
        bool enable_systime;
 
    } highspeed_link;
 
    bool enable_highspeed_link;
 
    lola::vx::v2::MemoryTiming memory_timing;
 
    haldls::vx::SynapseBiasSelection synapse_bias_selection;
 
    bool enable_capmem;
 
    haldls::vx::v2::ReferenceGeneratorConfig reference_generator_config;
 
    typedef halco::common::typed_array<
        haldls::vx::v2::CapMemBlockConfig,
        halco::hicann_dls::vx::v2::CapMemBlockConfigOnDLS>
        capmem_block_config_type GENPYBIND(visible);
    capmem_block_config_type capmem_block_config;
 
    typedef halco::common::
        typed_array<haldls::vx::v2::CapMemBlock, halco::hicann_dls::vx::v2::CapMemBlockOnDLS>
            capmem_block_type GENPYBIND(opaque(false));
    capmem_block_type capmem_config;
 
    typedef hate::Nil Result;
 
    GENPYBIND(stringstream)
    friend std::ostream& operator<<(std::ostream& os, InitGenerator const& sequence) SYMBOL_VISIBLE;
 
protected:
    PlaybackGeneratorReturn<Result> generate() const SYMBOL_VISIBLE;
 
private:
    friend auto stadls::vx::generate<InitGenerator>(InitGenerator const&);
};
 
} // namespace detail
 
class DigitalInit : public detail::InitGenerator
{
public:
    DigitalInit() SYMBOL_VISIBLE;
 
private:
    friend auto stadls::vx::generate<DigitalInit>(DigitalInit const&);
};
 
class ExperimentInit : public detail::InitGenerator
{
public:
    ExperimentInit() SYMBOL_VISIBLE;
 
    typedef PlaybackProgramBuilder Builder;
 
    typedef halco::common::typed_array<
        haldls::vx::CommonNeuronBackendConfig,
        halco::hicann_dls::vx::v2::CommonNeuronBackendConfigOnDLS>
        common_neuron_backend_config_type GENPYBIND(visible);
    common_neuron_backend_config_type common_neuron_backend_config;
 
    typedef halco::common::typed_array<
        haldls::vx::v2::ColumnCorrelationQuad,
        halco::hicann_dls::vx::v2::ColumnCorrelationQuadOnDLS>
        column_correlation_quad_type GENPYBIND(opaque(false));
    column_correlation_quad_type column_correlation_quad_config;
 
    typedef halco::common::typed_array<
        haldls::vx::v2::ColumnCurrentQuad,
        halco::hicann_dls::vx::v2::ColumnCurrentQuadOnDLS>
        column_current_quad_type GENPYBIND(opaque(false));
    column_current_quad_type column_current_quad_config;
 
    typedef halco::common::typed_array<
        haldls::vx::v2::CommonCorrelationConfig,
        halco::hicann_dls::vx::v2::CommonCorrelationConfigOnDLS>
        common_correlation_config_type GENPYBIND(opaque(false));
    common_correlation_config_type common_correlation_config;
 
    typedef detail::InitGenerator::Result Result;
 
private:
    friend auto stadls::vx::generate<ExperimentInit>(ExperimentInit const&);
 
    PlaybackGeneratorReturn<Result> generate() const SYMBOL_VISIBLE;
};
 
#if defined(__GENPYBIND__) or defined(__GENPYBIND_GENERATED__)
namespace detail {
 
struct GENPYBIND(expose_as(ExperimentInit), inline_base("*ExperimentInit*")) PyExperimentInit
    : public ExperimentInit
    , public PlaybackGenerator
{
    virtual pybind11::tuple generate() const override
    {
        return stadls::vx::detail::py_generate_impl(static_cast<ExperimentInit>(*this));
    }
};
 
// TODO: we can't use the alias above, cf. https://github.com/kljohann/genpybind/issues/32
struct GENPYBIND(expose_as(DigitalInit), inline_base("*DigitalInit*")) PyDigitalInit
    : public DigitalInit
    , public PlaybackGenerator
{
    virtual pybind11::tuple generate() const override
    {
        return stadls::vx::detail::py_generate_impl(static_cast<DigitalInit>(*this));
    }
};
 
} // namespace detail
#endif // defined(__GENPYBIND__) or defined(__GENPYBIND_GENERATED__)
 
GENPYBIND_MANUAL({
    parent.def(
        "generate",
        [](::stadls::vx::v2::ExperimentInit const& seq) {
            return ::stadls::vx::detail::py_generate_impl(seq);
        },
        pybind11::return_value_policy::move);
})
 
GENPYBIND_MANUAL({
    parent.def(
        "generate",
        [](::stadls::vx::v2::DigitalInit const& seq) {
            return ::stadls::vx::detail::py_generate_impl(seq);
        },
        pybind11::return_value_policy::move);
})
 
} // namespace stadls::vx::v2