From 0df2255bbd5231c25c0f2059f8b47c83ab9be41e Mon Sep 17 00:00:00 2001 From: David Steele Date: Tue, 20 Sep 2022 16:25:29 +0100 Subject: [PATCH] CORE-798 Make EL GIP Library FPGA Vendor Independent. FPM V8 - fpga vendor independent. Uses enc_pd_emul_3, event_logger_2, epd_diagnostics_8, pof_protocol_3, pulse_generator_6 (all fpga vendor independent) --- .../8/build/fire_pulse_manager_8.qip | 64 ++ .../8/build/fire_pulse_manager_8_hw.tcl | 295 ++++++ .../fire_pulse_manager/8/doc/epd_diags_8.json | 503 ++++++++++ .../fire_pulse_manager/8/doc/fpm_8.json | 67 ++ .../fire_pulse_manager/8/doc/fpm_ctrl_8.json | 500 ++++++++++ .../fire_pulse_manager/8/sim/com_fpm.do | 106 ++ .../fire_pulse_manager/8/sim/generate.bat | 9 + .../fire_pulse_manager/8/sim/sim_fpm.do | 60 ++ .../fire_pulse_manager/8/sim/sim_fpm_one.do | 60 ++ .../fire_pulse_manager/8/sim/sim_led.do | 50 + .../fire_pulse_manager/8/sim/wave_fpm.do | 693 ++++++++++++++ .../fire_pulse_manager/8/sim/wave_fpm_one.do | 89 ++ .../fire_pulse_manager/8/sim/wave_led.do | 103 ++ .../8/src/epd_diagnostics_8.vhd | 645 +++++++++++++ .../8/src/fire_pulse_8_pkg.vhd | 38 + .../8/src/fire_pulse_ctrl_8.vhd | 245 +++++ .../8/src/fire_pulse_manager_8.vhd | 905 ++++++++++++++++++ .../8/src/seb_epd_led_gen_8.vhd | 307 ++++++ .../8/src/simple_enc_vel_detect_8.vhd | 76 ++ .../src/test/fire_pulse_manager_8_one_tb.vhd | 826 ++++++++++++++++ .../test/fire_pulse_manager_8_one_tb_pkg.vhd | 869 +++++++++++++++++ .../8/src/test/fire_pulse_manager_8_tb.vhd | 785 +++++++++++++++ .../src/test/fire_pulse_manager_8_tb_pkg.vhd | 869 +++++++++++++++++ .../fire_pulse_manager/8/src/test/led_tb.vhd | 633 ++++++++++++ generic_ip/fire_pulse_manager/Readme.txt | 4 +- 25 files changed, 8800 insertions(+), 1 deletion(-) create mode 100644 generic_ip/fire_pulse_manager/8/build/fire_pulse_manager_8.qip create mode 100644 generic_ip/fire_pulse_manager/8/build/fire_pulse_manager_8_hw.tcl create mode 100644 generic_ip/fire_pulse_manager/8/doc/epd_diags_8.json create mode 100644 generic_ip/fire_pulse_manager/8/doc/fpm_8.json create mode 100644 generic_ip/fire_pulse_manager/8/doc/fpm_ctrl_8.json create mode 100644 generic_ip/fire_pulse_manager/8/sim/com_fpm.do create mode 100644 generic_ip/fire_pulse_manager/8/sim/generate.bat create mode 100644 generic_ip/fire_pulse_manager/8/sim/sim_fpm.do create mode 100644 generic_ip/fire_pulse_manager/8/sim/sim_fpm_one.do create mode 100644 generic_ip/fire_pulse_manager/8/sim/sim_led.do create mode 100644 generic_ip/fire_pulse_manager/8/sim/wave_fpm.do create mode 100644 generic_ip/fire_pulse_manager/8/sim/wave_fpm_one.do create mode 100644 generic_ip/fire_pulse_manager/8/sim/wave_led.do create mode 100644 generic_ip/fire_pulse_manager/8/src/epd_diagnostics_8.vhd create mode 100644 generic_ip/fire_pulse_manager/8/src/fire_pulse_8_pkg.vhd create mode 100644 generic_ip/fire_pulse_manager/8/src/fire_pulse_ctrl_8.vhd create mode 100644 generic_ip/fire_pulse_manager/8/src/fire_pulse_manager_8.vhd create mode 100644 generic_ip/fire_pulse_manager/8/src/seb_epd_led_gen_8.vhd create mode 100644 generic_ip/fire_pulse_manager/8/src/simple_enc_vel_detect_8.vhd create mode 100644 generic_ip/fire_pulse_manager/8/src/test/fire_pulse_manager_8_one_tb.vhd create mode 100644 generic_ip/fire_pulse_manager/8/src/test/fire_pulse_manager_8_one_tb_pkg.vhd create mode 100644 generic_ip/fire_pulse_manager/8/src/test/fire_pulse_manager_8_tb.vhd create mode 100644 generic_ip/fire_pulse_manager/8/src/test/fire_pulse_manager_8_tb_pkg.vhd create mode 100644 generic_ip/fire_pulse_manager/8/src/test/led_tb.vhd diff --git a/generic_ip/fire_pulse_manager/8/build/fire_pulse_manager_8.qip b/generic_ip/fire_pulse_manager/8/build/fire_pulse_manager_8.qip new file mode 100644 index 0000000..7057548 --- /dev/null +++ b/generic_ip/fire_pulse_manager/8/build/fire_pulse_manager_8.qip @@ -0,0 +1,64 @@ +set_global_assignment -name IP_TOOL_NAME "fire_pulse_manager_6" +set_global_assignment -name IP_TOOL_VERSION "18.0" +set_global_assignment -name IP_GENERATED_DEVICE_FAMILY "{Cyclone V}" + +set COMMON_PATH ../../../common/0/src +set POF_PATH_0 ../../../pof_protocol/0/src +set POF_PATH_1 ../../../pof_protocol/1/src +set SEQUENCER_PATH ../../../generic_sequencer/16/src +set PULSE_GEN_PATH ../../../pulse_generator/2/src +set EMUL_PATH ../../../enc_pd_emul/1/src +set LOG_PATH ../../../event_logger/0/src +set SRC_PATH ../src + +# common +set_global_assignment -name VHDL_FILE [file join $::quartus(qip_path) "$COMMON_PATH/sync_reset.vhd"] +set_global_assignment -name VHDL_FILE [file join $::quartus(qip_path) "$COMMON_PATH/common_pkg.vhd"] +set_global_assignment -name VHDL_FILE [file join $::quartus(qip_path) "$COMMON_PATH/sync_wire.vhd"] +set_global_assignment -name VHDL_FILE [file join $::quartus(qip_path) "$COMMON_PATH/sync_wire_rEdge.vhd"] +set_global_assignment -name VHDL_FILE [file join $::quartus(qip_path) "$COMMON_PATH/altera/sync_fifo.vhd"] +set_global_assignment -name VHDL_FILE [file join $::quartus(qip_path) "$COMMON_PATH/queue_and_delay.vhd"] +set_global_assignment -name VHDL_FILE [file join $::quartus(qip_path) "$COMMON_PATH/dpram_sclk.vhd"] +set_global_assignment -name VHDL_FILE [file join $::quartus(qip_path) "$COMMON_PATH/alt_rw_dp_ram.vhd"] + +# Generic Sequencer +#set_global_assignment -name VHDL_FILE [file join $::quartus(qip_path) "$SEQUENCER_PATH/altera/generic_seq_ram_16.vhd"] +set_global_assignment -name VHDL_FILE [file join $::quartus(qip_path) "$SEQUENCER_PATH/generic_sequencer_16_pkg.vhd"] +set_global_assignment -name VHDL_FILE [file join $::quartus(qip_path) "$SEQUENCER_PATH/generic_sequencer_16.vhd"] + +# Pulse Generator +set_global_assignment -name VHDL_FILE [file join $::quartus(qip_path) "$PULSE_GEN_PATH/simple_frac_div_3.vhd"] +set_global_assignment -name VHDL_FILE [file join $::quartus(qip_path) "$PULSE_GEN_PATH/pulse_generator_3_pkg.vhd"] +set_global_assignment -name VHDL_FILE [file join $::quartus(qip_path) "$PULSE_GEN_PATH/pulse_generator_3.vhd"] + +# Emulator +set_global_assignment -name VHDL_FILE [file join $::quartus(qip_path) "$EMUL_PATH/enc_pd_emul_1_pkg.vhd"] +set_global_assignment -name VHDL_FILE [file join $::quartus(qip_path) "$EMUL_PATH/enc_pd_emul_1.vhd"] + +# Event Logger +set_global_assignment -name VHDL_FILE [file join $::quartus(qip_path) "$LOG_PATH/event_logger_0_pkg.vhd"] +set_global_assignment -name VHDL_FILE [file join $::quartus(qip_path) "$LOG_PATH/event_logger_0.vhd"] + +# POF-Rx +set_global_assignment -name VHDL_FILE [file join $::quartus(qip_path) "$POF_PATH_0/pof_uart_rx_0.vhd"] +set_global_assignment -name VHDL_FILE [file join $::quartus(qip_path) "$POF_PATH_0/pof_rx_0.vhd"] +set_global_assignment -name VHDL_FILE [file join $::quartus(qip_path) "$POF_PATH_0/pof_uart_regen_0.vhd"] +set_global_assignment -name VHDL_FILE [file join $::quartus(qip_path) "$POF_PATH_0/uart_tx_0.vhd"] +set_global_assignment -name VHDL_FILE [file join $::quartus(qip_path) "$POF_PATH_0/pof_tx_0.vhd"] + +set_global_assignment -name VHDL_FILE [file join $::quartus(qip_path) "$POF_PATH_1/pof_uart_rx_1.vhd"] +set_global_assignment -name VHDL_FILE [file join $::quartus(qip_path) "$POF_PATH_1/pof_rx_1.vhd"] +set_global_assignment -name VHDL_FILE [file join $::quartus(qip_path) "$POF_PATH_1/pof_uart_regen_1.vhd"] +set_global_assignment -name VHDL_FILE [file join $::quartus(qip_path) "$POF_PATH_1/uart_tx_1.vhd"] +set_global_assignment -name VHDL_FILE [file join $::quartus(qip_path) "$POF_PATH_1/pof_tx_1.vhd"] + +# Fire-Pulse-Manager +set_global_assignment -name VHDL_FILE [file join $::quartus(qip_path) "$COMMON_PATH/cs_bus_itf.vhd"] +set_global_assignment -name VHDL_FILE [file join $::quartus(qip_path) "$SRC_PATH/smb_diagnostics_6.vhd"] +set_global_assignment -name VHDL_FILE [file join $::quartus(qip_path) "$SRC_PATH/simple_enc_vel_detect_6.vhd"] +set_global_assignment -name VHDL_FILE [file join $::quartus(qip_path) "$SRC_PATH/fire_pulse_6_pkg.vhd"] +set_global_assignment -name VHDL_FILE [file join $::quartus(qip_path) "$SRC_PATH/fire_pulse_ctrl_6.vhd"] +set_global_assignment -name VHDL_FILE [file join $::quartus(qip_path) "$SRC_PATH/fire_pulse_manager_6.vhd"] + + + diff --git a/generic_ip/fire_pulse_manager/8/build/fire_pulse_manager_8_hw.tcl b/generic_ip/fire_pulse_manager/8/build/fire_pulse_manager_8_hw.tcl new file mode 100644 index 0000000..74466b1 --- /dev/null +++ b/generic_ip/fire_pulse_manager/8/build/fire_pulse_manager_8_hw.tcl @@ -0,0 +1,295 @@ +# TCL File Generated by Component Editor 16.0 +# Wed Oct 25 15:26:07 BST 2017 +# DO NOT MODIFY + + +# +# fire_pulse_manager_0 "fire_pulse_manager_6" v1.0 +# GMG 2017.10.25.15:26:07 +# Fire Pulse Manager +# + +# +# request TCL package from ACDS 16.0 +# +package require -exact qsys 16.0 + + +# +# module fire_pulse_manager_0 +# +set_module_property DESCRIPTION "Fire Pulse Manager" +set_module_property NAME fire_pulse_manager_6 +set_module_property VERSION 1.0 +set_module_property INTERNAL false +set_module_property OPAQUE_ADDRESS_MAP true +set_module_property GROUP "GIS Components" +set_module_property AUTHOR GMG +set_module_property DISPLAY_NAME fire_pulse_manager_6 +set_module_property INSTANTIATE_IN_SYSTEM_MODULE true +set_module_property EDITABLE true +set_module_property REPORT_TO_TALKBACK false +set_module_property ALLOW_GREYBOX_GENERATION false +set_module_property REPORT_HIERARCHY false + + +# +# file sets +# +add_fileset QUARTUS_SYNTH QUARTUS_SYNTH "" "" +set_fileset_property QUARTUS_SYNTH TOP_LEVEL fire_pulse_manager_6 +set_fileset_property QUARTUS_SYNTH ENABLE_RELATIVE_INCLUDE_PATHS false +set_fileset_property QUARTUS_SYNTH ENABLE_FILE_OVERWRITE_MODE false +#add_fileset_file pkg_functions.vhd VHDL PATH ../../../common/0/src/pkg_functions.vhd +add_fileset_file common_pkg.vhd VHDL PATH ../../../common/0/src/common_pkg.vhd +add_fileset_file sync_reset.vhd VHDL PATH ../../../common/0/src/sync_reset.vhd +add_fileset_file sync_wire.vhd VHDL PATH ../../../common/0/src/sync_wire.vhd +add_fileset_file sync_wire_rEdge.vhd VHDL PATH ../../../common/0/src/sync_wire_rEdge.vhd +add_fileset_file fifo_1024x32.vhd VHDL PATH ../../../common/0//src/altera/fifo_1024x32.vhd +add_fileset_file fifo_256x32.vhd VHDL PATH ../../../common/0/src/altera/fifo_256x32.vhd +add_fileset_file sync_fifo.vhd VHDL PATH ../../../common/0/src/altera/sync_fifo.vhd +add_fileset_file cs_bus_itf.vhd VHDL PATH ../../../common/0/src/cs_bus_itf.vhd +add_fileset_file dpram_sclk.vhd VHDL PATH ../../../common/0/src/dpram_sclk.vhd +add_fileset_file alt_rw_dp_ram.vhd VHDL PATH ../../../common/0/src/altera/alt_rw_dp_ram.vhd +#add_fileset_file generic_seq_ram_16.vhd VHDL PATH ../../../generic_sequencer/16/src/altera/generic_seq_ram_16.vhd +add_fileset_file generic_sequencer_16_pkg.vhd VHDL PATH ../../../generic_sequencer/16/src/generic_sequencer_16_pkg.vhd +add_fileset_file generic_sequencer_16.vhd VHDL PATH ../../../generic_sequencer/16/src/generic_sequencer_16.vhd +add_fileset_file enc_pd_emul_1_pkg.vhd VHDL PATH ../../../enc_pd_emul/1/src/enc_pd_emul_1_pkg.vhd +add_fileset_file enc_pd_emul_1.vhd VHDL PATH ../../../enc_pd_emul/1/src/enc_pd_emul_1.vhd +add_fileset_file event_logger_0_pkg.vhd VHDL PATH ../../../event_logger/0/src/event_logger_0_pkg.vhd +add_fileset_file event_logger_0.vhd VHDL PATH ../../../event_logger/0/src/event_logger_0.vhd +add_fileset_file queue_and_delay.vhd VHDL PATH ../../../common/0/src/queue_and_delay.vhd +add_fileset_file simple_frac_div_3.vhd VHDL PATH ../../../pulse_generator/3/src/simple_frac_div_3.vhd +add_fileset_file pulse_generator_3_pkg.vhd VHDL PATH ../../../pulse_generator/3/src/pulse_generator_3_pkg.vhd +add_fileset_file pulse_generator_3.vhd VHDL PATH ../../../pulse_generator/3/src/pulse_generator_3.vhd +add_fileset_file pof_uart_rx_0.vhd VHDL PATH ../../../pof_protocol/0/src/pof_uart_rx_0.vhd +add_fileset_file pof_rx_0.vhd VHDL PATH ../../../pof_protocol/0/src/pof_rx_0.vhd +add_fileset_file pof_uart_regen_0.vhd VHDL PATH ../../../pof_protocol/0/src/pof_uart_regen_0.vhd +add_fileset_file pof_uart_rx_1.vhd VHDL PATH ../../../pof_protocol/1/src/pof_uart_rx_1.vhd +add_fileset_file pof_rx_1.vhd VHDL PATH ../../../pof_protocol/1/src/pof_rx_1.vhd +add_fileset_file pof_uart_regen_1.vhd VHDL PATH ../../../pof_protocol/1/src/pof_uart_regen_1.vhd +add_fileset_file smb_diagnostics_6.vhd VHDL PATH ../src/smb_diagnostics_6.vhd +add_fileset_file fire_pulse_6_pkg.vhd VHDL PATH ../src/fire_pulse_6_pkg.vhd +add_fileset_file simple_enc_vel_detect_6.vhd VHDL PATH ../src/simple_enc_vel_detect_6.vhd +add_fileset_file fire_pulse_ctrl_6.vhd VHDL PATH ../src/fire_pulse_ctrl_6.vhd +add_fileset_file fire_pulse_manager_6.vhd VHDL PATH ../src/fire_pulse_manager_6.vhd TOP_LEVEL_FILE + +add_fileset SIM_VHDL SIM_VHDL "" "" +set_fileset_property SIM_VHDL TOP_LEVEL fire_pulse_manager_6 +set_fileset_property SIM_VHDL ENABLE_RELATIVE_INCLUDE_PATHS false +set_fileset_property SIM_VHDL ENABLE_FILE_OVERWRITE_MODE false +add_fileset_file common_pkg.vhd VHDL PATH ../../../common/0/src/common_pkg.vhd +add_fileset_file sync_reset.vhd VHDL PATH ../../../common/0/src/sync_reset.vhd +add_fileset_file sync_wire.vhd VHDL PATH ../../../common/0/src/sync_wire.vhd +add_fileset_file sync_wire_rEdge.vhd VHDL PATH ../../../common/0/src/sync_wire_rEdge.vhd +add_fileset_file fifo_1024x32.vhd VHDL PATH ../../../common/0//src/altera/fifo_1024x32.vhd +add_fileset_file fifo_256x32.vhd VHDL PATH ../../../common/0/src/altera/fifo_256x32.vhd +add_fileset_file sync_fifo.vhd VHDL PATH ../../../common/0/src/altera/sync_fifo.vhd +add_fileset_file cs_bus_itf.vhd VHDL PATH ../../../common/0/src/cs_bus_itf.vhd +add_fileset_file dpram_sclk.vhd VHDL PATH ../../../common/0/src/dpram_sclk.vhd +add_fileset_file alt_rw_dp_ram.vhd VHDL PATH ../../../common/0/src/altera/alt_rw_dp_ram.vhd +#add_fileset_file generic_seq_ram_16.vhd VHDL PATH ../../../generic_sequencer/16/src/altera/generic_seq_ram_16.vhd +add_fileset_file generic_sequencer_16_pkg.vhd VHDL PATH ../../../generic_sequencer/16/src/generic_sequencer_16_pkg.vhd +add_fileset_file generic_sequencer_16.vhd VHDL PATH ../../../generic_sequencer/16/src/generic_sequencer_16.vhd +add_fileset_file enc_pd_emul_1_pkg.vhd VHDL PATH ../../../enc_pd_emul/1/src/enc_pd_emul_1_pkg.vhd +add_fileset_file enc_pd_emul_1.vhd VHDL PATH ../../../enc_pd_emul/1/src/enc_pd_emul_1.vhd +add_fileset_file event_logger_0_pkg.vhd VHDL PATH ../../../event_logger/0/src/event_logger_0_pkg.vhd +add_fileset_file event_logger_0.vhd VHDL PATH ../../../event_logger/0/src/event_logger_0.vhd +add_fileset_file queue_and_delay.vhd VHDL PATH ../../../common/0/src/queue_and_delay.vhd +add_fileset_file simple_frac_div_3.vhd VHDL PATH ../../../pulse_generator/3/src/simple_frac_div_3.vhd +add_fileset_file pulse_generator_3_pkg.vhd VHDL PATH ../../../pulse_generator/3/src/pulse_generator_3_pkg.vhd +add_fileset_file pulse_generator_3.vhd VHDL PATH ../../../pulse_generator/3/src/pulse_generator_3.vhd +add_fileset_file pof_uart_rx_0.vhd VHDL PATH ../../../pof_protocol/0/src/pof_uart_rx_0.vhd +add_fileset_file pof_rx_0.vhd VHDL PATH ../../../pof_protocol/0/src/pof_rx_0.vhd +add_fileset_file pof_uart_regen_0.vhd VHDL PATH ../../../pof_protocol/0/src/pof_uart_regen_0.vhd +add_fileset_file pof_uart_rx_1.vhd VHDL PATH ../../../pof_protocol/1/src/pof_uart_rx_1.vhd +add_fileset_file pof_rx_1.vhd VHDL PATH ../../../pof_protocol/1/src/pof_rx_1.vhd +add_fileset_file pof_uart_regen_1.vhd VHDL PATH ../../../pof_protocol/1/src/pof_uart_regen_1.vhd +add_fileset_file smb_diagnostics_6.vhd VHDL PATH ../src/smb_diagnostics_6.vhd +add_fileset_file fire_pulse_6_pkg.vhd VHDL PATH ../src/fire_pulse_6_pkg.vhd +add_fileset_file simple_enc_vel_detect_6.vhd VHDL PATH ../src/simple_enc_vel_detect_6.vhd +add_fileset_file fire_pulse_ctrl_6.vhd VHDL PATH ../src/fire_pulse_ctrl_6.vhd +add_fileset_file fire_pulse_manager_6.vhd VHDL PATH ../src/fire_pulse_manager_6.vhd + + +# +# parameters +# + + +# +# display items +# + + +# +# connection point clock +# +add_interface clock clock end +set_interface_property clock clockRate 0 +set_interface_property clock ENABLED true +set_interface_property clock EXPORT_OF "" +set_interface_property clock PORT_NAME_MAP "" +set_interface_property clock CMSIS_SVD_VARIABLES "" +set_interface_property clock SVD_ADDRESS_GROUP "" + +add_interface_port clock clk clk Input 1 + + +# +# connection point reset +# +add_interface reset reset end +set_interface_property reset associatedClock clock +set_interface_property reset synchronousEdges DEASSERT +set_interface_property reset ENABLED true +set_interface_property reset EXPORT_OF "" +set_interface_property reset PORT_NAME_MAP "" +set_interface_property reset CMSIS_SVD_VARIABLES "" +set_interface_property reset SVD_ADDRESS_GROUP "" + +add_interface_port reset reset_n reset_n Input 1 + + +# +# connection point avs +# +add_interface avs avalon end +set_interface_property avs addressUnits WORDS +set_interface_property avs associatedClock clock +set_interface_property avs associatedReset reset +set_interface_property avs bitsPerSymbol 8 +set_interface_property avs burstOnBurstBoundariesOnly false +set_interface_property avs burstcountUnits WORDS +set_interface_property avs explicitAddressSpan 0 +set_interface_property avs holdTime 0 +set_interface_property avs linewrapBursts false +set_interface_property avs maximumPendingReadTransactions 0 +set_interface_property avs maximumPendingWriteTransactions 0 +set_interface_property avs readLatency 0 +set_interface_property avs readWaitTime 1 +set_interface_property avs setupTime 0 +set_interface_property avs timingUnits Cycles +set_interface_property avs writeWaitTime 0 +set_interface_property avs ENABLED true +set_interface_property avs EXPORT_OF "" +set_interface_property avs PORT_NAME_MAP "" +set_interface_property avs CMSIS_SVD_VARIABLES "" +set_interface_property avs SVD_ADDRESS_GROUP "" + +add_interface_port avs avs_address address Input 15 +add_interface_port avs avs_write write Input 1 +add_interface_port avs avs_writedata writedata Input 32 +add_interface_port avs avs_read read Input 1 +add_interface_port avs avs_readdata readdata Output 32 +add_interface_port avs avs_waitrequest waitrequest Output 1 +set_interface_assignment avs embeddedsw.configuration.isFlash 0 +set_interface_assignment avs embeddedsw.configuration.isMemoryDevice 0 +set_interface_assignment avs embeddedsw.configuration.isNonVolatileStorage 0 +set_interface_assignment avs embeddedsw.configuration.isPrintableDevice 0 + + +# +# connection point conduit_end +# +add_interface conduit_end conduit end +set_interface_property conduit_end associatedClock clock +set_interface_property conduit_end associatedReset reset +set_interface_property conduit_end ENABLED true +set_interface_property conduit_end EXPORT_OF "" +set_interface_property conduit_end PORT_NAME_MAP "" +set_interface_property conduit_end CMSIS_SVD_VARIABLES "" +set_interface_property conduit_end SVD_ADDRESS_GROUP "" + +add_interface_port conduit_end pof_rx pof_rx Input 1 +add_interface_port conduit_end pof_tx pof_tx Output 1 +add_interface_port conduit_end pof_iso_en pof_iso_en Output 1 +add_interface_port conduit_end fire_pulse fire_pulse Output 1 +add_interface_port conduit_end abs_pos_out abs_pos_out Output 32 +add_interface_port conduit_end print_start print_start Output 1 +add_interface_port conduit_end dp_dir_out dp_dir_out Output 1 +add_interface_port conduit_end mon_pt mon_pt Output 4 + + +# +# connection point rx_clk +# +add_interface rx_clk clock end +set_interface_property rx_clk clockRate 0 +set_interface_property rx_clk ENABLED true +set_interface_property rx_clk EXPORT_OF "" +set_interface_property rx_clk PORT_NAME_MAP "" +set_interface_property rx_clk CMSIS_SVD_VARIABLES "" +set_interface_property rx_clk SVD_ADDRESS_GROUP "" + +add_interface_port rx_clk rx_clk clk Input 1 + + +# +# connection point irq_0 +# +add_interface irq_0 interrupt end +set_interface_property irq_0 associatedAddressablePoint "" +set_interface_property irq_0 associatedClock clock +set_interface_property irq_0 associatedReset reset +set_interface_property irq_0 bridgedReceiverOffset "" +set_interface_property irq_0 bridgesToReceiver "" +set_interface_property irq_0 ENABLED true +set_interface_property irq_0 EXPORT_OF "" +set_interface_property irq_0 PORT_NAME_MAP "" +set_interface_property irq_0 CMSIS_SVD_VARIABLES "" +set_interface_property irq_0 SVD_ADDRESS_GROUP "" + +add_interface_port irq_0 ins_fpm_irq_0 irq Output 1 + +# +# connection point irq_1 +# +add_interface irq_1 interrupt end +set_interface_property irq_1 associatedAddressablePoint "" +set_interface_property irq_1 associatedClock clock +set_interface_property irq_1 associatedReset reset +set_interface_property irq_1 bridgedReceiverOffset "" +set_interface_property irq_1 bridgesToReceiver "" +set_interface_property irq_1 ENABLED true +set_interface_property irq_1 EXPORT_OF "" +set_interface_property irq_1 PORT_NAME_MAP "" +set_interface_property irq_1 CMSIS_SVD_VARIABLES "" +set_interface_property irq_1 SVD_ADDRESS_GROUP "" + +add_interface_port irq_1 ins_fpm_irq_1 irq Output 1 + +# +# connection point irq_2 +# +add_interface irq_2 interrupt end +set_interface_property irq_2 associatedAddressablePoint "" +set_interface_property irq_2 associatedClock clock +set_interface_property irq_2 associatedReset reset +set_interface_property irq_2 bridgedReceiverOffset "" +set_interface_property irq_2 bridgesToReceiver "" +set_interface_property irq_2 ENABLED true +set_interface_property irq_2 EXPORT_OF "" +set_interface_property irq_2 PORT_NAME_MAP "" +set_interface_property irq_2 CMSIS_SVD_VARIABLES "" +set_interface_property irq_2 SVD_ADDRESS_GROUP "" + +add_interface_port irq_2 ins_fpm_irq_2 irq Output 1 + +# +# connection point irq_3 +# +add_interface irq_3 interrupt end +set_interface_property irq_3 associatedAddressablePoint "" +set_interface_property irq_3 associatedClock clock +set_interface_property irq_3 associatedReset reset +set_interface_property irq_3 bridgedReceiverOffset "" +set_interface_property irq_3 bridgesToReceiver "" +set_interface_property irq_3 ENABLED true +set_interface_property irq_3 EXPORT_OF "" +set_interface_property irq_3 PORT_NAME_MAP "" +set_interface_property irq_3 CMSIS_SVD_VARIABLES "" +set_interface_property irq_3 SVD_ADDRESS_GROUP "" + +add_interface_port irq_3 ins_fpm_irq_3 irq Output 1 + diff --git a/generic_ip/fire_pulse_manager/8/doc/epd_diags_8.json b/generic_ip/fire_pulse_manager/8/doc/epd_diags_8.json new file mode 100644 index 0000000..f49121d --- /dev/null +++ b/generic_ip/fire_pulse_manager/8/doc/epd_diags_8.json @@ -0,0 +1,503 @@ +[ + { + "ip_name": "epd_diags_8", + "bus": "csr", + "addr_width": "6", + "description": "Fire Pulse Manager Encoder / PD diagnostics - used to monitor encoder / PD inputs", + "notes": "

Diagnostics for the Fire Pulse Manager for use when the SEB-EPD inputs are connected. Details on confluence via https://congis.atlassian.net/wiki/spaces/EL/pages/26778599541/Notes+on+FPM+changes+to+support+auto+generated+registers#epd_diags_8 This is optionally instantiated in FPM_8 based on a generic. (presence will be reported in fpm_ctrl registers.

When the ESW wants to read the encoder fifo, the ESW should: a. write '1' to register rd_enc_fifo to prepare the encoder fifo output; b. read the encoder fifo output from register enc_fifo_output.

When the ESW wants to read the product detect fifo, the ESW should: a. write '1' to register rd_pd_fifo to prepare the product detect fifo output;b. read the product detect fifo output from register pd_fifo_output.

", + "registers": { + "init": { + "address": "0", + "width": "7", + "description": "Diagnostic reset", + "fields": { + "init": { + "type": "w", + "bit_len": "1", + "reset": "0x0", + "description": "initialize the full diagnostic block" + }, + "rst_counters": { + "type": "w", + "bit_len": "1", + "reset": "0x0", + "description": "reset only edge counters" + }, + "rst_measur": { + "type": "w", + "bit_len": "1", + "reset": "0x0", + "description": "reset only time-based velocity/acceleration measurement registers" + }, + "rst_dir": { + "type": "w", + "bit_len": "1", + "reset": "0x0", + "description": "reset only the logic for direction detection" + }, + "rst_enc_fifo": { + "type": "w", + "bit_len": "1", + "reset": "0x0", + "description": "reset only the encoder fifo" + }, + "rst_pos": { + "type": "w", + "bit_len": "1", + "reset": "0x0", + "description": "reset only the position detection register" + }, + "rst_pd_fifo": { + "type": "w", + "bit_len": "1", + "reset": "0x0", + "description": "reset only the PD fifo" + } + } + }, + "rd_enc_fifo": { + "address": "1", + "width": "1", + "description": "Read Enc FIFO", + "type": "wp", + "reset": "0x0" + }, + "rd_pd_fifo": { + "address": "2", + "width": "1", + "description": "Read the PD fifo", + "type": "wp", + "reset": "0x0" + }, + "input_status": { + "address": "3", + "width": "17", + "description": "Instantaneous status of input signals", + "fields": { + "rs422_p1": { + "type": "r", + "bit_len": "1", + "reset": "0x00", + "description": "RS422 encoder phase-1" + }, + "rs422_p2": { + "type": "r", + "bit_len": "1", + "reset": "0x00", + "description": "RS422 encoder phase-2" + }, + "rs422_zp": { + "type": "r", + "bit_len": "1", + "reset": "0x00", + "description": "RS422 encoder zero-phase" + }, + "rs422_pd": { + "type": "r", + "bit_len": "1", + "reset": "0x00", + "description": "RS422 Product Detect" + }, + "ttl_p1": { + "type": "r", + "bit_len": "1", + "reset": "0x00", + "description": "TTL encoder phase-1" + }, + "ttl_p2": { + "type": "r", + "bit_len": "1", + "reset": "0x00", + "description": "TTL encoder phase-2" + }, + "ttl_zp": { + "type": "r", + "bit_len": "1", + "reset": "0x00", + "description": "TTL encoder zero-phase" + }, + "ttl_pd_pnp": { + "type": "r", + "bit_len": "1", + "reset": "0x00", + "description": "TTL (PNP) Product Detect" + }, + "ttl_pd_npn": { + "type": "r", + "bit_len": "1", + "reset": "0x00", + "description": "TTL (NPN) Product Detect" + }, + "filt_p1": { + "type": "r", + "bit_len": "1", + "reset": "0x00", + "description": "EMS filtered p1" + }, + "filt_p2": { + "type": "r", + "bit_len": "1", + "reset": "0x00", + "description": "EMS filtered p2" + }, + "filt_zp": { + "type": "r", + "bit_len": "1", + "reset": "0x00", + "description": "EMS filtered zp" + }, + "filt_pd": { + "type": "r", + "bit_len": "1", + "reset": "0x00", + "description": "EMS filtered pd" + }, + "enc_pulse": { + "type": "r", + "bit_len": "1", + "reset": "0x00", + "description": "enc_pulse (after jitter removal)" + }, + "pd_out": { + "type": "r", + "bit_len": "1", + "reset": "0x00", + "description": "PD output" + }, + "drop_watch": { + "type": "r", + "bit_len": "1", + "reset": "0x00", + "description": "drop watch)" + }, + "fire_req": { + "type": "r", + "bit_len": "1", + "reset": "0x00", + "description": "fire request" + } + } + }, + "phase1_counter": { + "type": "r", + "address": "4", + "reset": "0x0", + "width": "32", + "description": "Encoder Phase-1 (filtered) edge counter" + }, + "phase2_counter": { + "type": "r", + "address": "5", + "reset": "0x0", + "width": "32", + "description": "Encoder Phase-2 (filtered) edge counter" + }, + "zero_phase_counter": { + "type": "r", + "address": "6", + "reset": "0x0", + "width": "32", + "description": "Encoder Zero-Phase (filtered) edge counter" + }, + "pd_counter": { + "type": "r", + "address": "7", + "reset": "0x0", + "width": "32", + "description": "PD (filtered) edge counter" + }, + "enc_pulse_counter": { + "type": "r", + "address": "8", + "reset": "0x0", + "width": "32", + "description": "encoder pulse counter (after jitter removal)" + }, + "pd_output_counter": { + "type": "r", + "address": "9", + "reset": "0x0", + "width": "32", + "description": "PD output edge counter" + }, + "fire_request_counter": { + "type": "r", + "address": "10", + "reset": "0x0", + "width": "32", + "description": "Fire-Request counter" + }, + "delta_time_meas": { + "type": "r", + "address": "11", + "reset": "0x0", + "width": "32", + "description": "Delta-time measurement" + }, + "deltamin_time_meas": { + "type": "r", + "address": "12", + "reset": "0x0", + "width": "32", + "description": "Delta-time-min measurement" + }, + "deltamax_time_meas": { + "type": "r", + "address": "13", + "reset": "0x0", + "width": "32", + "description": "Delta-time-max measurement" + }, + "delta_time_prev_meas": { + "type": "r", + "address": "14", + "reset": "0x0", + "width": "32", + "description": "Previous delta-time measurement" + }, + "delta_time_meas_step": { + "type": "w", + "address": "15", + "reset": "0x0", + "width": "16", + "description": "Delta-time measurement step" + }, + "abs_pos": { + "type": "r", + "address": "16", + "reset": "0x0", + "width": "32", + "description": "Detected absolution position (DEPRECATED)" + }, + "dir_thres": { + "address": "17", + "width": "32", + "description": "Direction detection control", + "fields": { + "pos_dir_thres": { + "type": "w", + "bit_len": "16", + "reset": "0x007F", + "description": "threshold for positive direction detection" + }, + "neg_dir_thres": { + "type": "w", + "bit_len": "16", + "reset": "0xFF81", + "description": "threshold for negative direction detection" + } + } + }, + "dir_cnt": { + "address": "18", + "width": "32", + "description": "Direction status", + "fields": { + "dir_cnt": { + "type": "r", + "bit_len": "16", + "reset": "0x0", + "description": "direction count" + }, + "dir_change_cnt": { + "type": "r", + "bit_len": "16", + "reset": "0x0", + "description": "direction change count" + } + } + }, + "enc_sampling_period": { + "type": "w", + "address": "19", + "reset": "0x0", + "width": "28", + "description": "Encoder sampling period (encoder FIFO)" + }, + "enc_fifo_mng_w": { + "address": "20", + "width": "16", + "description": "encoder FIFO management", + "fields": { + "irq_gen_thres": { + "type": "w", + "bit_len": "10", + "reset": "0x0", + "description": "FIFO IRQ threshold" + }, + "reserved-0": { + "type": "rsv", + "bit_len": "6", + "description": "Reserved bits" + } + } + }, + "enc_fifo_mng_r": { + "address": "21", + "width": "16", + "description": "encoder FIFO management", + "fields": { + "fifo_level": { + "type": "r", + "bit_len": "10", + "reset": "0x0", + "description": "fifo level" + }, + "reserved-1": { + "type": "rsv", + "bit_len": "5", + "description": "Reserved bits" + }, + "fifo_overflow": { + "type": "r", + "bit_len": "1", + "reset": "0x0", + "description": "fifo overflow flag" + } + } + }, + "enc_fifo_output": { + "type": "r", + "address": "22", + "reset": "0x0", + "width": "32", + "description": "Encoder FIFO output" + }, + "pd_fifo_mng_w": { + "address": "23", + "width": "16", + "description": "encoder FIFO management", + "fields": { + "irq_gen_thres": { + "type": "w", + "bit_len": "8", + "reset": "0x0", + "description": "FIFO IRQ threshold" + }, + "reserved-0": { + "type": "rsv", + "bit_len": "7", + "description": "Reserved bits" + }, + "pd_log_src": { + "type": "w", + "bit_len": "1", + "reset": "0x0", + "description": "PD log source: 0 => PD-FIFO associated to PD pulse at the input of the Pulse-Generator, 1 => PD-FIFO associated to output of the PD Queue on the first channel" + } + } + }, + "pd_fifo_mng_r": { + "address": "24", + "width": "16", + "description": "encoder FIFO management", + "fields": { + "fifo_level": { + "type": "r", + "bit_len": "8", + "reset": "0x0", + "description": "fifo level" + }, + "reserved-1": { + "type": "rsv", + "bit_len": "7", + "description": "Reserved bits" + }, + "fifo_overflow": { + "type": "r", + "bit_len": "1", + "reset": "0x0", + "description": "fifo overflow flag" + } + } + }, + "pd_fifo_output": { + "type": "r", + "address": "25", + "reset": "0x0", + "width": "32", + "description": "PD FIFO output" + }, + "pd_watchdog_ctrl": { + "address": "26", + "width": "2", + "description": "PD watchdog control", + "fields": { + "watchdog_en": { + "type": "w", + "bit_len": "1", + "reset": "0x0", + "description": "PD watchdog enable" + }, + "watchdog_clr": { + "type": "w", + "bit_len": "1", + "reset": "0x0", + "description": "PD watchdog clear" + } + } + }, + "pd_watchdog_status": { + "address": "27", + "width": "1", + "reset": "0x0", + "type": "r", + "description": "watchdog status" + }, + "pd_watchdog_thres": { + "type": "w", + "address": "28", + "reset": "0x0", + "width": "32", + "description": "PD watchdog threshold" + }, + "irq_mng": { + "address": "29", + "width": "12", + "description": "Diagnostic block IRQ management", + "fields": { + "irq_en": { + "type": "w", + "bit_len": "3", + "reset": "0x0", + "description": "IRQ enable" + }, + "reserved-0": { + "type": "rsv", + "bit_len": "1", + "description": "Reserved bits" + }, + "irq_clr": { + "type": "w", + "bit_len": "3", + "reset": "0x0", + "description": "IRQ clear" + }, + "reserved-1": { + "type": "rsv", + "bit_len": "1", + "description": "Reserved bits" + }, + "irq_mask": { + "type": "w", + "bit_len": "3", + "reset": "0x0", + "description": "IRQ mask" + }, + "reserved-2": { + "type": "rsv", + "bit_len": "1", + "description": "Reserved bits" + } + } + }, + "irq_value": { + "address": "30", + "width": "3", + "description": "IRQ value", + "type": "r", + "reset": "0x0" + } + } + } +] \ No newline at end of file diff --git a/generic_ip/fire_pulse_manager/8/doc/fpm_8.json b/generic_ip/fire_pulse_manager/8/doc/fpm_8.json new file mode 100644 index 0000000..7139313 --- /dev/null +++ b/generic_ip/fire_pulse_manager/8/doc/fpm_8.json @@ -0,0 +1,67 @@ +[{ + "ip_name" : "fpm_8", + "bus" : "csr", + "addr_width" : "15", + "addr_hi_bit" : "14", + "addr_lo_bit" : "11", + "description" : "Fire-Pulse-Manager version 8", + "notes": "The Fire Pulse Manager produces fire-request strobe signals to trigger the print_units to load and fire the printhead (or sub-head). It does so based on either received UART messages over Plastic Optic Fibre (POF) if using the SEB-PDW, or from encoder/PD inputs if using the SEB-EPD. Full details on confluence at https://congis.atlassian.net/wiki/spaces/EL/pages/26742062920/Fire+Pulse+Manager#FPM---v8", + "sub_blocks" : { + "fpm_ctrl_8" : { + "instance" : "", + "process" : "enabled", + "offset" : "0x0000" + }, + "epd_diags_8" : { + "instance" : "", + "process" : "enabled", + "note" : "This block is instantiated only when generic ADD_EPD_DIAGS is set to true", + "offset" : "0x0800" + }, + "event_logger_2" : { + "instance" : "", + "process" : "cpp, txt", + "note" : "This block is instantiated only when generic ADD_EVENT_LOGGER is set to true", + "offset" : "0x1000" + }, + "enc_pd_emul_3" : { + "instance" : "", + "process" : "enabled", + "offset" : "0x1800" + }, + "ems_1" : { + "instance" : "", + "process" : "cpp, txt", + "offset" : "0x2000" + }, + "pof_tx_3" : { + "instance" : "", + "process" : "cpp, txt", + "offset" : "0x2800" + }, + "pulse_generator_6:a" : { + "instance" : "0", + "process" : "enabled", + "offset" : "0x3000" + }, + "pulse_generator_6:b" : { + "instance" : "1", + "process" : "enabled", + "note" : "This block may not be instantiated depending on the value of generic CH_NUM specified in the FPM top-level", + "offset" : "0x3800" + }, + "pulse_generator_6:c" : { + "instance" : "2", + "process" : "enabled", + "note" : "This block may not be instantiated depending on the value of generic CH_NUM specified in the FPM top-level", + "offset" : "0x4000" + }, + "pulse_generator_6:d" : { + "instance" : "3", + "process" : "enabled", + "note" : "This block may not be instantiated depending on the value of generic CH_NUM specified in the FPM top-level", + "offset" : "0x4800" + } + } +} +] diff --git a/generic_ip/fire_pulse_manager/8/doc/fpm_ctrl_8.json b/generic_ip/fire_pulse_manager/8/doc/fpm_ctrl_8.json new file mode 100644 index 0000000..fe015a7 --- /dev/null +++ b/generic_ip/fire_pulse_manager/8/doc/fpm_ctrl_8.json @@ -0,0 +1,500 @@ +[{ + "ip_name": "fpm_ctrl_8", + "bus": "csr", + "addr_width" : "5", + "description": "This block is the fire pulse manager control", + "notes": "This is the control registers for the Fire Pulse Manager. https://congis.atlassian.net/wiki/spaces/EL/pages/26742062920/Fire+Pulse+Manager#FPM---v7. The Fire Pulse Manager produces fire-request strobe signals to trigger the print_units to load and fire the printhead (or sub-head). It does so based on either received UART messages over Plastic Optic Fibre (POF) if using the SEB-PDW, or from encoder/PD inputs if using the SEB-EPD. Full details on confluence at https://congis.atlassian.net/wiki/spaces/EL/pages/26742062920/Fire+Pulse+Manager#FPM---v8", + "registers": { + "ip_id" : { + "address" : "0", + "width" : "32", + "description" : "Unique ID for this IP block", + "fields": { + "ip_number" : { + "type" : "c", + "bit_len" : "8", + "reset" : "0x14", + "description" : "IP identifier number" + }, + "mfr_number" : { + "type" : "c", + "bit_len" : "8", + "reset" : "0xFF", + "description" : "Manufacturer number" + + }, + "reserved" : { + "type" : "rsv", + "bit_len" : "16", + "description" : "Reserved bits" + } + } + }, + "ip_ver" : { + "address" : "1", + "width" : "32", + "description" : "IP Version", + "fields": { + "minor_number" : { + "type" : "c", + "bit_len" : "8", + "reset" : "0x00", + "description" : "Minor number" + }, + "major_number" : { + "type" : "c", + "bit_len" : "8", + "reset" : "0x08", + "description" : "Major number" + + }, + "reserved" : { + "type" : "rsv", + "bit_len" : "16", + "description" : "Reserved bits" + } + } + }, + "fpm_config": { + "address": "2", + "width": "10", + "description": "Configuration values for the FPM", + "fields": { + "ch_num" : { + "type" : "r", + "bit_len" : "4", + "reset" : "0", + "description" : "Number of channels" + }, + "seb_epd_logic_present" : { + "type" : "r", + "bit_len" : "1", + "reset" : "0", + "description" : "0 => SEB-EPD logic not present, 1 => SEB-EPD logic present" + }, + "epd_diagnostic_present" : { + "type" : "r", + "bit_len" : "1", + "reset" : "0", + "description" : "0 => EPD diagnostic block not present, 1 => EPD diagnostic block present. Encoder Product Detect Diagnostics. Previously called smb_diags" + }, + "event_logger_present" : { + "type" : "r", + "bit_len" : "1", + "reset" : "0", + "description" : "0 => Event Logger block not present, 1 => Event Logger block present" + }, + "delay_equalization_enable" : { + "type" : "r", + "bit_len" : "1", + "reset" : "0", + "description" : "0 => No support for delay equalization, 1 => Support for delay equalization" + }, + "tof_comp_enable" : { + "type" : "r", + "bit_len" : "1", + "reset" : "0", + "description" : "0 => No support for Time-of-Flight compensation, 1 => Support for Time-of-Flight compensation" + }, + "pixel_pitch_corr_enable" : { + "type" : "r", + "bit_len" : "1", + "reset" : "0", + "description" : "0 => No support for pixel-pitch correction, 1 => Support for pixel-pitch correction" + } + } + }, + "fpm_init_start": { + "address": "3", + "width": "1", + "type" : "w", + "reset" : "0", + "description" : "Start the fpm_init procedure" + }, + "fpm_init_done": { + "address": "4", + "width": "1", + "type" : "r", + "reset" : "0", + "description" : "fpm_init completed flag" + }, + "signal_selection": { + "address": "5", + "width": "6", + "description": "Controls signal selection", + "fields": { + "fire_pulse_sel": { + "type": "w", + "bit_len": "1", + "reset": "0x0", + "description": "0 => Use External fire pulses, 1 => Use FPM fire pulses" + }, + "enc_pd_emul_en": { + "type": "w", + "bit_len": "1", + "reset": "0x0", + "description": "0 => Use POF RX, 1 => Use internal enc/PD emulator" + }, + "seb_epd_en": { + "type": "w", + "bit_len": "1", + "reset": "0x0", + "description": "1 => Enable SEB-EPD interface, 0 => Use POF based interface" + }, + "seb_epd_linkout_sel": { + "type": "w", + "bit_len": "1", + "reset": "0x0", + "description": "0 => SEB_EPD_LINK_OUT is driven by the POF-Tx output, 0 => SEB_EPD_LINK_OUT is driven by the Drop-Watch output" + }, + "print_start_override": { + "type": "w", + "bit_len": "2", + "reset": "0x0", + "description": "0- => no override. 10 => override to zero (stop print). 11 => override to one (start print). output of FPM and value for pof_tx" + } + } + }, + "pof_receiver_control": { + "address": "6", + "width": "9", + "description": "Controls POF receiver", + "fields": { + "pof_rx_enable": { + "type": "w", + "bit_len": "1", + "reset": "0x0", + "description": "0 => Disable POF RX, 1 => Enable POF RX" + }, + "uart_regeneration_bypass": { + "type": "w", + "bit_len": "1", + "reset": "0x0", + "description": "0 => Use UART Regeneration, 1 => Bypass UART Regeneration" + }, + "clear_max": { + "type": "w", + "bit_len": "1", + "reset": "0x0", + "description": "0 => Disabled, 1 => Load the current value of Absolute Position as new maximum" + }, + "clear_min": { + "type": "w", + "bit_len": "1", + "reset": "0x0", + "description": "0 => Disabled, 1 => Load the current value of Absolute Position as new miniumum" + }, + "uart_rx_div": { + "type": "w", + "bit_len": "4", + "reset": "0x4", + "description": "Defines the number of 200 MHz clock cycles per UART data bit" + }, + "pof_protocol_version": { + "type": "w", + "bit_len": "1", + "reset": "0", + "description": "0 => Support POF protocol version 0, 1 => Support POF protocol version 1 (allows print_start message)" + } + } + }, + "monitoring_point_selection": { + "address": "7", + "width": "16", + "description": "Selects monitoring points for external header", + "fields": { + "mp0": { + "type": "w", + "bit_len": "4", + "reset": "0x0", + "description": "Selects first monitoring point" + }, + "mp1": { + "type": "w", + "bit_len": "4", + "reset": "0x0", + "description": "Selects second monitoring point" + }, + "mp2": { + "type": "w", + "bit_len": "4", + "reset": "0x0", + "description": "Selects third monitoring point" + }, + "mp3": { + "type": "w", + "bit_len": "4", + "reset": "0x0", + "description": "Selects fourth monitoring point" + } + } + }, + "coarse_time_init": { + "type": "w", + "address": "8", + "reset": "0x00000000", + "width": "32", + "description": "Defines coarse time counter value" + }, + "fine_time_init": { + "address": "9", + "width": "29", + "description": "Fine time counter value/Load counter enable", + "fields": { + "fine_time_init": { + "type" :"w", + "bit_len": "28", + "reset": "0x0000000", + "description": "Defines fine time counter value" + }, + "time_load_en": { + "type" :"w", + "bit_len" : "1", + "reset": "0x0", + "description" : "Writting 1 loads the coarse and fine time counters" + } + } + }, + "fine_time_status": { + "type": "r", + "address": "10", + "reset": "0x0000000", + "width": "28", + "description": "Current fine time counter value" + }, + "coarse_time_status": { + "type": "r", + "address": "11", + "reset": "0x00000000", + "width": "32", + "description": "Current coarse time counter value" + }, + "pof_rx_status": { + "address": "12", + "width": "32", + "description": "Status of POF receiver", + "fields": { + "parity_bit_error_count": { + "type": "r", + "bit_len": "16", + "reset": "0x0000", + "description": "Counts number of parity errors" + }, + "skipped_position_error_count": { + "type": "r", + "bit_len": "16", + "reset": "0x0000", + "description": "Counts position skipped type errors" + } + } + }, + "pof_rx_control_w": { + "address": "13", + "width": "10", + "description": "POF receiver error control", + "fields": { + "error_rate_thres": { + "type" : "w", + "bit_len": "8", + "reset": "0x0A", + "description": "Defines RX error rate threshold" + }, + "rx_watchdog_en": { + "type": "w", + "bit_len": "1", + "reset": "0x1", + "description": "0 => Disable RX watchdog, 1 => Enable RX Watchdog" + }, + "rx_watchdog_clr": { + "type": "w", + "bit_len": "1", + "reset": "0x0", + "description": "0 => RX watchdog counter running, 1 => Clear RX watchdog counter" + } + } + }, + "pof_rx_control_r": { + "address": "14", + "width": "3", + "description": "POF receiver error status", + "fields": { + "rx_watchdog": { + "type": "r", + "bit_len": "1", + "reset": "0x0", + "description": "0 => RX watchdog not triggered, 1 => RX watchdog triggered" + }, + "rx_error_flag": { + "type": "r", + "bit_len": "1", + "reset": "0x0", + "description": "0 => Error rate below threshold, 1 => Error rate above threshold" + }, + "print_start_received": { + "type": "r", + "bit_len": "1", + "reset": "0x0", + "description": "print_start as received over pof. (for protocol zero, will be fixed at '1')" + } + } + }, + "fpm_interrupt": { + "address": "15", + "width": "12", + "description": "Interrupt control", + "fields": { + "irq_en": { + "type": "w", + "bit_len": "1", + "reset": "0x0", + "description": "0 => Disable IRQ, 1 => Enable IRQ" + }, + "reserved1": { + "type": "rsv", + "bit_len": "3", + "description": "Reserved" + }, + "irq_clr": { + "type": "w", + "bit_len": "1", + "reset": "0x0", + "description": "0 => Don't clear pending IRQ, 1 => Clear pending IRQ" + }, + "reserved2": { + "type": "rsv", + "bit_len": "3", + "description": "Reserved" + }, + "irq_mask": { + "type": "w", + "bit_len": "1", + "reset": "0x0", + "description": "0 => IRQ not masked, 1 => IRQ masked" + }, + "reserved3": { + "type": "rsv", + "bit_len": "3", + "description": "Reserved" + } + } + }, + "irq_status": { + "address": "16", + "width": "1", + "type": "r", + "bit_len": "1", + "reset": "0x0", + "description": "0 => IRQ not active, 1 => IRQ active" + }, + "pd_cnt": { + "address": "17", + "width": "16", + "type": "r", + "reset": "0x0", + "description": "PD count, at the Pulse-Generator input" + }, + "drop_watch_config": { + "address": "18", + "width": "32", + "description": "Drop-Watch configuration", + "fields": { + "dw_src": { + "type": "w", + "bit_len": "4", + "reset": "0x0", + "description": "Select the source channel for the drop-watch" + }, + "reserved": { + "type": "rsv", + "bit_len": "12", + "description": "Reserved" + }, + "dw_pulse_width": { + "type": "w", + "bit_len": "16", + "reset": "0x000A", + "description": "Drop-Watch pulse width, expressed as clock cycles @100MHz" + } + } + }, + "seb_epd_led_status": { + "address": "19", + "width": "12", + "description": "SEB-EPD LED status", + "fields": { + "led_pd_g": { + "type": "r", + "bit_len": "1", + "reset": "0x0", + "description": "LED PD Green" + }, + "led_pd_y": { + "type": "r", + "bit_len": "1", + "reset": "0x0", + "description": "LED PD Yellow" + }, + "led_pd_r": { + "type": "r", + "bit_len": "1", + "reset": "0x0", + "description": "LED PD Red" + }, + "led_enc_p1_g": { + "type": "r", + "bit_len": "1", + "reset": "0x0", + "description": "LED Encoder-Phase-1 Green" + }, + "led_enc_p1_y": { + "type": "r", + "bit_len": "1", + "reset": "0x0", + "description": "LED Encoder-Phase-1 Yellow" + }, + "led_enc_p1_r": { + "type": "r", + "bit_len": "1", + "reset": "0x0", + "description": "LED Encoder-Phase-1 Red" + }, + "led_enc_p2_g": { + "type": "r", + "bit_len": "1", + "reset": "0x0", + "description": "LED Encoder-Phase-2 Green" + }, + "led_enc_p2_y": { + "type": "r", + "bit_len": "1", + "reset": "0x0", + "description": "LED Encoder-Phase-2 Yellow" + }, + "led_enc_p2_r": { + "type": "r", + "bit_len": "1", + "reset": "0x0", + "description": "LED Encoder-Phase-2 Red" + }, + "led_pof_in_g": { + "type": "r", + "bit_len": "1", + "reset": "0x0", + "description": "LED POF-In Green" + }, + "led_pof_in_y": { + "type": "r", + "bit_len": "1", + "reset": "0x0", + "description": "LED POF-In Yellow" + }, + "led_pof_in_r": { + "type": "r", + "bit_len": "1", + "reset": "0x0", + "description": "LED POF-In Red" + } + } + } + } + }] diff --git a/generic_ip/fire_pulse_manager/8/sim/com_fpm.do b/generic_ip/fire_pulse_manager/8/sim/com_fpm.do new file mode 100644 index 0000000..6256bf4 --- /dev/null +++ b/generic_ip/fire_pulse_manager/8/sim/com_fpm.do @@ -0,0 +1,106 @@ +# Multi-channel FPM compilation macro: +# To prevent cleaning the existing work library at the beginning run the command with "--nocleanup" option: +# do com_fpm.do --nocleanup + +set DO_CLEANUP 1 + +if { $argc >= 1 } { + set PARAM $1 + if { $PARAM == "--nocleanup" } { + set DO_CLEANUP 0 + } +} + +if { $DO_CLEANUP == 1 } { + .main clear + + # Cleanup libraries + foreach lib [list work ] { + file delete -force -- $lib + vlib $lib + } +} + +# Path variables +set COMMON_PATH ../../../common/0/src +set POF_PATH_2 ../../../pof_protocol/2/src +set SEQUENCER_PATH ../../../generic_sequencer/ +set PULSE_GEN_PATH ../../../pulse_generator/6/src +set EMUL_PATH ../../../enc_pd_emul/2/src +set EMS_PATH ../../../ems/1/src +set ENC_MULT_PATH ../../../encoder_multiply/0/src +set LOG_PATH ../../../event_logger/1/src +set SRC_PATH ../src +set OSVVM_PATH ../../../common/0/src/test/OSVVM +set TB_PATH ../src/test + +set WORKLIB work + +vlib ./work +vmap work ./work + +# common +vcom -2008 -work $WORKLIB $COMMON_PATH/sync_reset.vhd +vcom -2008 -work $WORKLIB $COMMON_PATH/common_pkg.vhd +vcom -2008 -work $WORKLIB $COMMON_PATH/sync_wire.vhd +vcom -2008 -work $WORKLIB $COMMON_PATH/sync_pulse.vhd +vcom -2008 -work $WORKLIB $COMMON_PATH/sync_pulse_vec_push.vhd +vcom -2008 -work $WORKLIB $COMMON_PATH/sync_wire_rEdge.vhd +vcom -2008 -work $WORKLIB $COMMON_PATH/altera/sync_fifo.vhd +vcom -2008 -work $WORKLIB $COMMON_PATH/queue_and_delay.vhd +vcom -2008 -work $WORKLIB $COMMON_PATH/dpram_sclk.vhd +vcom -2008 -work $WORKLIB $COMMON_PATH/digital_lpf.vhd +vcom -2008 -work $WORKLIB $COMMON_PATH/altera/alt_rw_dp_ram.vhd + +# Generic Sequencer +vcom -2008 -work $WORKLIB $SEQUENCER_PATH/19/src/generic_sequencer_19_cmd_pkg.vhd +vcom -2008 -work $WORKLIB $SEQUENCER_PATH/19/src/generic_sequencer_19_pkg_auto.vhd +vcom -2008 -work $WORKLIB $SEQUENCER_PATH/19/src/generic_sequencer_19_csr_regs_auto.vhd +vcom -2008 -work $WORKLIB $SEQUENCER_PATH/19/src/generic_sequencer_19.vhd + +# Pulse Generator +vcom -2008 -work $WORKLIB $PULSE_GEN_PATH/simple_frac_div_6.vhd +vcom -2008 -work $WORKLIB $PULSE_GEN_PATH/pulse_generator_6_pkg_auto.vhd +vcom -2008 -work $WORKLIB $PULSE_GEN_PATH/pulse_generator_6_csr_regs_auto.vhd +vcom -2008 -work $WORKLIB $PULSE_GEN_PATH/pulse_generator_6.vhd + +# Emulator +vcom -2008 -work $WORKLIB $EMUL_PATH/enc_pd_emul_2_pkg_auto.vhd +vcom -2008 -work $WORKLIB $EMUL_PATH/enc_pd_emul_2_csr_regs_auto.vhd +vcom -2008 -work $WORKLIB $EMUL_PATH/enc_pd_emul_2.vhd + +# EMS +vcom -2008 -work $WORKLIB $ENC_MULT_PATH/lut_divider_0.vhd +vcom -2008 -work $WORKLIB $ENC_MULT_PATH/encoder_speed_detect_0.vhd +vcom -2008 -work $WORKLIB $ENC_MULT_PATH/encoder_multiply_0.vhd +vcom -2008 -work $WORKLIB $EMS_PATH/ems_1_pkg_auto.vhd +vcom -2008 -work $WORKLIB $EMS_PATH/ems_1_csr_regs_auto.vhd +vcom -2008 -work $WORKLIB $EMS_PATH/ems_1.vhd + +# Event Logger +vcom -2008 -work $WORKLIB $LOG_PATH/event_logger_1_pkg_auto.vhd +vcom -2008 -work $WORKLIB $LOG_PATH/event_logger_1_csr_regs_auto.vhd +vcom -2008 -work $WORKLIB $LOG_PATH/event_logger_1.vhd + +# POF-Rx +vcom -2008 -work $WORKLIB $POF_PATH_2/pof_uart_rx_2.vhd +vcom -2008 -work $WORKLIB $POF_PATH_2/pof_rx_2.vhd +vcom -2008 -work $WORKLIB $POF_PATH_2/pof_uart_regen_2.vhd +vcom -2008 -work $WORKLIB $POF_PATH_2/uart_tx_2.vhd +vcom -2008 -work $WORKLIB $POF_PATH_2/pof_tx_2_pkg_auto.vhd +vcom -2008 -work $WORKLIB $POF_PATH_2/pof_tx_2_csr_regs_auto.vhd +vcom -2008 -work $WORKLIB $POF_PATH_2/pof_tx_2.vhd + +# Fire-Pulse-Manager +vcom -2008 -work $WORKLIB $COMMON_PATH/cs_bus_itf_no_wait.vhd +vcom -2008 -work $WORKLIB $SRC_PATH/epd_diags_7_pkg_auto.vhd +vcom -2008 -work $WORKLIB $SRC_PATH/epd_diags_7_csr_regs_auto.vhd +vcom -2008 -work $WORKLIB $SRC_PATH/epd_diagnostics_7.vhd +vcom -2008 -work $WORKLIB $SRC_PATH/simple_enc_vel_detect_7.vhd +vcom -2008 -work $WORKLIB $SRC_PATH/fire_pulse_7_pkg.vhd +vcom -2008 -work $WORKLIB $SRC_PATH/fpm_ctrl_7_pkg_auto.vhd +vcom -2008 -work $WORKLIB $SRC_PATH/fpm_ctrl_7_csr_regs_auto.vhd +vcom -2008 -work $WORKLIB $SRC_PATH/fire_pulse_ctrl_7.vhd +vcom -2008 -work $WORKLIB $SRC_PATH/seb_epd_led_gen_7.vhd +vcom -2008 -work $WORKLIB $SRC_PATH/fire_pulse_manager_7.vhd + diff --git a/generic_ip/fire_pulse_manager/8/sim/generate.bat b/generic_ip/fire_pulse_manager/8/sim/generate.bat new file mode 100644 index 0000000..af2aeb2 --- /dev/null +++ b/generic_ip/fire_pulse_manager/8/sim/generate.bat @@ -0,0 +1,9 @@ +python.exe ..\..\..\..\..\fw_development_tools\logic_memory_mapper\gen_hdl.py -b csr seq -s "_auto" -j ..\..\..\pulse_generator\6\doc\pulse_generator_6.json -o ..\..\..\pulse_generator\6\src\ +python.exe ..\..\..\..\..\fw_development_tools\logic_memory_mapper\gen_hdl.py -b csr seq -s "_auto" -j ..\..\..\enc_pd_emul\3\doc\enc_pd_emul_3.json -o ..\..\..\enc_pd_emul\3\src\ +python.exe ..\..\..\..\..\fw_development_tools\logic_memory_mapper\gen_hdl.py -b csr seq -s "_auto" -j ..\..\..\ems\1\doc\ems_1.json -o ..\..\..\ems\1\src\ +python.exe ..\..\..\..\..\fw_development_tools\logic_memory_mapper\gen_hdl.py -b csr seq -s "_auto" -j ..\..\..\event_logger\2\doc\event_logger_2.json -o ..\..\..\event_logger\2\src\ +python.exe ..\..\..\..\..\fw_development_tools\logic_memory_mapper\gen_hdl.py -b csr seq -s "_auto" -j ..\..\..\pof_protocol\3\doc\pof_tx_3.json -o ..\..\..\pof_protocol\3\src\ +python.exe ..\..\..\..\..\fw_development_tools\logic_memory_mapper\gen_hdl.py -b csr seq -s "_auto" -j ..\..\..\generic_sequencer\19\doc\generic_sequencer_19.json -o ..\..\..\generic_sequencer\19\src\ +python.exe ..\..\..\..\..\fw_development_tools\logic_memory_mapper\gen_hdl.py -b csr seq -s "_auto" -j ..\doc\fpm_8.json -o ..\src\ +python.exe ..\..\..\..\..\fw_development_tools\logic_memory_mapper\gen_hdl.py -b csr seq -s "_auto" -j ..\doc\fpm_ctrl_8.json -o ..\src\ +python.exe ..\..\..\..\..\fw_development_tools\logic_memory_mapper\gen_hdl.py -b csr seq -s "_auto" -j ..\doc\epd_diags_8.json -o ..\src\ diff --git a/generic_ip/fire_pulse_manager/8/sim/sim_fpm.do b/generic_ip/fire_pulse_manager/8/sim/sim_fpm.do new file mode 100644 index 0000000..b10b585 --- /dev/null +++ b/generic_ip/fire_pulse_manager/8/sim/sim_fpm.do @@ -0,0 +1,60 @@ +# Multi-channel FPM Simulation macro + +.main clear + +# Cleanup libraries +foreach lib [list work OSVVM] { + file delete -force -- $lib + vlib $lib +} + +# Path variables +set OSVVM_PATH ../../../common/0/src/test/OSVVM +set TB_PATH ../src/test + +set WORKLIB work + +vlib ./work +vmap work ./work + +do com_fpm.do --nocleanup + +# Compile the testbench support files: +# Compile OSVVM lib +vlib OSVVM +vcom -2008 -work OSVVM $OSVVM_PATH/RandomBasePkg.vhd +vcom -2008 -work OSVVM $OSVVM_PATH/SortListPkg_int.vhd +vcom -2008 -work OSVVM $OSVVM_PATH/RandomPkg.vhd + +# Compile the testbench support files: +vcom -2008 -work $WORKLIB $COMMON_PATH/test/common_test_pkg.vhd +vcom -2008 -work $WORKLIB $COMMON_PATH/test/log_pkg.vhd + +# Compile the VHDL packages that support bus protocols, memory mapped registers and functional procedures +vcom -2008 -work $WORKLIB $COMMON_PATH/test/avalon_verify_pkg_2.vhd + +# Testbench support package +vcom -2008 -work $WORKLIB $TB_PATH/fire_pulse_manager_7_tb_pkg.vhd + +# Testbench +vcom -2008 -work $WORKLIB $TB_PATH/fire_pulse_manager_7_tb.vhd + +# Load design +vsim -t ps work.fire_pulse_manager_7_tb + +# Add waves +#add wave -r sim:/fire_pulse_manager_7_tb/* +do wave_fpm.do + +# remove warnings from standard numeric/arithmetic packages (speed-up simulation) +set StdArithNoWarnings 1 +set NumericStdNoWarnings 1 + +when -label end_of_simulation {test_completed == true} {echo "Simulation Completed"; stop ;} +run -all + + + + + + diff --git a/generic_ip/fire_pulse_manager/8/sim/sim_fpm_one.do b/generic_ip/fire_pulse_manager/8/sim/sim_fpm_one.do new file mode 100644 index 0000000..3fd2913 --- /dev/null +++ b/generic_ip/fire_pulse_manager/8/sim/sim_fpm_one.do @@ -0,0 +1,60 @@ +# Multi-channel FPM Simulation macro + +.main clear + +# Cleanup libraries +foreach lib [list work OSVVM] { + file delete -force -- $lib + vlib $lib +} + +# Path variables +set OSVVM_PATH ../../../common/0/src/test/OSVVM +set TB_PATH ../src/test + +set WORKLIB work + +vlib ./work +vmap work ./work + +do com_fpm.do --nocleanup + +# Compile the testbench support files: +# Compile OSVVM lib +vlib OSVVM +vcom -2008 -work OSVVM $OSVVM_PATH/RandomBasePkg.vhd +vcom -2008 -work OSVVM $OSVVM_PATH/SortListPkg_int.vhd +vcom -2008 -work OSVVM $OSVVM_PATH/RandomPkg.vhd + +# Compile the testbench support files: +vcom -2008 -work $WORKLIB $COMMON_PATH/test/common_test_pkg.vhd +vcom -2008 -work $WORKLIB $COMMON_PATH/test/log_pkg.vhd + +# Compile the VHDL packages that support bus protocols, memory mapped registers and functional procedures +vcom -2008 -work $WORKLIB $COMMON_PATH/test/avalon_verify_pkg_2.vhd + +# Testbench support package +vcom -2008 -work $WORKLIB $TB_PATH/fire_pulse_manager_7_one_tb_pkg.vhd + +# Testbench +vcom -2008 -work $WORKLIB $TB_PATH/fire_pulse_manager_7_one_tb.vhd + +# Load design +vsim -t ps work.fire_pulse_manager_8_one_tb + +# Add waves +#add wave -r sim:/fire_pulse_manager_8_tb/* +do wave_fpm.do + +# remove warnings from standard numeric/arithmetic packages (speed-up simulation) +set StdArithNoWarnings 1 +set NumericStdNoWarnings 1 + +when -label end_of_simulation {test_completed == true} {echo "Simulation Completed"; stop ;} +run -all + + + + + + diff --git a/generic_ip/fire_pulse_manager/8/sim/sim_led.do b/generic_ip/fire_pulse_manager/8/sim/sim_led.do new file mode 100644 index 0000000..a390065 --- /dev/null +++ b/generic_ip/fire_pulse_manager/8/sim/sim_led.do @@ -0,0 +1,50 @@ +# Simulation macro + +#.main clear + +set OSVVM_PATH ../../../common/0/src/test/OSVVM +set COMMON_PATH ../../../common/0/src + +set WORKLIB work + +vlib ./work +vmap work ./work + +# Compile the UUT +vcom -2008 -work $WORKLIB $COMMON_PATH/sync_wire.vhd +vcom -2008 -work $WORKLIB ../src/seb_epd_led_gen_8.vhd + +# Compile the constrained random related packages +vlib OSVVM +vcom -2008 -work OSVVM \ + $OSVVM_PATH/RandomBasePkg.vhd \ + $OSVVM_PATH/SortListPkg_int.vhd \ + $OSVVM_PATH/RandomPkg.vhd \ + $OSVVM_PATH/NamePkg.vhd \ + $OSVVM_PATH/MessagePkg.vhd \ + $OSVVM_PATH/CoveragePkg.vhd + +# Compile support files +vcom -2008 -work $WORKLIB $COMMON_PATH/test/common_test_pkg.vhd +vcom -2008 -work $WORKLIB $COMMON_PATH/test/log_pkg.vhd +vcom -2008 -work $WORKLIB $COMMON_PATH//test/avalon_verify_pkg.vhd + +# Compile the testbench +vcom -2008 -work $WORKLIB ./../src/test/led_tb.vhd + +vsim -t ps work.led_tb + + +#add wave /led_tb/* +#add wave /led_tb/iUUT/* + +# remove warnings from standard numeric/arithmetic packages (speed-up simulation) +set StdArithNoWarnings 1 +set NumericStdNoWarnings 1 + +do wave_led.do + +when -label end_of_simulation {test_completed == true} {echo "Simulation Completed"; stop ;} +run -all + +#run 200 us; \ No newline at end of file diff --git a/generic_ip/fire_pulse_manager/8/sim/wave_fpm.do b/generic_ip/fire_pulse_manager/8/sim/wave_fpm.do new file mode 100644 index 0000000..f06f624 --- /dev/null +++ b/generic_ip/fire_pulse_manager/8/sim/wave_fpm.do @@ -0,0 +1,693 @@ +onerror {resume} +quietly WaveActivateNextPane {} 0 +add wave -noupdate /fire_pulse_manager_7_tb/tb_fpm_init_tx +add wave -noupdate /fire_pulse_manager_7_tb/iPOF_TX/init +add wave -noupdate /fire_pulse_manager_7_tb/tb_fpm_init_done +add wave -noupdate /fire_pulse_manager_7_tb/iDUT/iCTRL/fpm_init_start +add wave -noupdate /fire_pulse_manager_7_tb/iDUT/iCTRL/fpm_init_done +add wave -noupdate /fire_pulse_manager_7_tb/iPOF_TX/init_blk_cnt +add wave -noupdate /fire_pulse_manager_7_tb/iDUT/init +add wave -noupdate /fire_pulse_manager_7_tb/iDUT/remote_init +add wave -noupdate -group TB -expand /fire_pulse_manager_7_tb/ch_offset +add wave -noupdate -group TB /fire_pulse_manager_7_tb/reset_n +add wave -noupdate -group TB /fire_pulse_manager_7_tb/clk +add wave -noupdate -group TB /fire_pulse_manager_7_tb/rx_clk +add wave -noupdate -group TB -expand /fire_pulse_manager_7_tb/ch_pulse_out +add wave -noupdate -group TB -expand /fire_pulse_manager_7_tb/ch_start_of_img +add wave -noupdate -group TB -expand /fire_pulse_manager_7_tb/ch_fire_pulse +add wave -noupdate -group TB -expand /fire_pulse_manager_7_tb/ch_start_of_image +add wave -noupdate -group TB /fire_pulse_manager_7_tb/avs_address +add wave -noupdate -group TB /fire_pulse_manager_7_tb/avs_write +add wave -noupdate -group TB /fire_pulse_manager_7_tb/avs_writedata +add wave -noupdate -group TB /fire_pulse_manager_7_tb/avs_read +add wave -noupdate -group TB /fire_pulse_manager_7_tb/avs_readdata +add wave -noupdate -group TB /fire_pulse_manager_7_tb/rst_fp_cnt +add wave -noupdate -group TB /fire_pulse_manager_7_tb/ext_pulse +add wave -noupdate -group TB /fire_pulse_manager_7_tb/ext_pulse_enable +add wave -noupdate -group TB /fire_pulse_manager_7_tb/inc_pos +add wave -noupdate -group TB /fire_pulse_manager_7_tb/dec_pos +add wave -noupdate -group TB -radix unsigned /fire_pulse_manager_7_tb/abs_position +add wave -noupdate -group TB /fire_pulse_manager_7_tb/swathe_cnt +add wave -noupdate -group TB /fire_pulse_manager_7_tb/enc_p1 +add wave -noupdate -group TB /fire_pulse_manager_7_tb/enc_p2 +add wave -noupdate -group TB /fire_pulse_manager_7_tb/pd +add wave -noupdate -group TB /fire_pulse_manager_7_tb/seb_epd_enc_p1 +add wave -noupdate -group TB /fire_pulse_manager_7_tb/seb_epd_enc_p2 +add wave -noupdate -group TB /fire_pulse_manager_7_tb/seb_epd_pd +add wave -noupdate -group TB /fire_pulse_manager_7_tb/end_of_swathe +add wave -noupdate -group TB /fire_pulse_manager_7_tb/test_completed +add wave -noupdate -group TB /fire_pulse_manager_7_tb/running +add wave -noupdate -group TB /fire_pulse_manager_7_tb/configuring +add wave -noupdate -group TB /fire_pulse_manager_7_tb/passed +add wave -noupdate -group TB /fire_pulse_manager_7_tb/failed +add wave -noupdate -group TB /fire_pulse_manager_7_tb/stimuli_completed +add wave -noupdate -group TB /fire_pulse_manager_7_tb/error_flag +add wave -noupdate -group TB /fire_pulse_manager_7_tb/registers_read +add wave -noupdate -group TB /fire_pulse_manager_7_tb/reprogram_offset +add wave -noupdate -group TB /fire_pulse_manager_7_tb/avs_m +add wave -noupdate -group TB /fire_pulse_manager_7_tb/avs_s +add wave -noupdate -group TB /fire_pulse_manager_7_tb/pd_cnt +add wave -noupdate -group TB /fire_pulse_manager_7_tb/fp_cnt +add wave -noupdate -group TB /fire_pulse_manager_7_tb/run_dw +add wave -noupdate -group TB /fire_pulse_manager_7_tb/dw +add wave -noupdate -group TB /fire_pulse_manager_7_tb/dw_cnt +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/reset_n +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/clk +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/rx_clk +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/pof_rx +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/pof_tx +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/pof_iso_en +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/seb_epd_enc_p1 +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/seb_epd_enc_p2 +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/seb_epd_pd +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/fire_pulse +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/start_of_image +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/dp_dir_out +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/abs_pos_out +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/print_start +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/mon_pt +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/ins_fpm_irq_0 +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/ins_fpm_irq_1 +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/ins_fpm_irq_2 +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/ins_fpm_irq_3 +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/avs_address +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/avs_write +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/avs_writedata +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/avs_read +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/avs_readdata +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/reset_n_i +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/cs_addr +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/cs_write_en +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/cs_write_data +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/cs_read_en +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/cs_read_data +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/cs_ctrl_write_en +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/cs_ctrl_read_en +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/cs_ctrl_read_data +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/cs_pg_write_en +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/cs_pg_read_en +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/cs_pg_read_data +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/cs_diag_write_en +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/cs_diag_read_en +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/cs_diag_read_data +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/cs_log_write_en +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/cs_log_read_en +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/cs_log_read_data +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/cs_ie_write_en +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/cs_ie_read_en +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/cs_ie_read_data +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/cs_ems_write_en +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/cs_ems_read_en +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/cs_ems_read_data +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/cs_pof_write_en +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/cs_pof_read_en +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/cs_pof_read_data +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/enable_rx +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/uart_regen_bypass +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/max_error_flag +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/rx_watchdog +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/rx_watchdog_en +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/rx_watchdog_clr +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/print_start_i +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/dw_src +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/error_rate_thres +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/parity_err_cnt +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/skip_pos_cnt +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/mon_point_src +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/dw_pulse_width +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/fine_time +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/coarse_time +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/init +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/remote_init +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/dp_dir +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/set_pos_ie +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/enc_pulse +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/pd_pulse +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/pd_pulse_ie +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/pd_pulse_pof +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/pd_ems +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/inc_pos +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/inc_pos_pof +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/inc_pos_ie +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/inc_pos_ems +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/dec_pos +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/dec_pos_pof +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/dec_pos_ie +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/dec_pos_ems +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/abs_pos +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/abs_pos_pof +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/abs_pos_ems +add wave -noupdate -group {FPM top} -radix decimal /fire_pulse_manager_7_tb/iDUT/abs_pos_ie +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/pd_pulse_mux +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/enc_p1_mux +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/enc_p2_mux +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/enc_p1_ie +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/enc_p2_ie +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/pof_tx_data +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/dw_pulse +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/dw_pulse_i +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/rst_dw_pulse +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/set_dw_pulse +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/dw_pulse_cnt +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/ch_pd +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/ch_raw_pulse +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/ch_mask +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/ch_start_of_image +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/src_sel +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/vel_meas +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/vel_sampling_per +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/one_pps +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/log_data_src +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/ext_fp_in_sync +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/ext_fp_in +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/ext_fp_in_d +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/ext_fp +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/pEXT_PULSE_DETECT/pulse_width_cnt +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/pEXT_PULSE_DETECT/pulse_cnt_en +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/led_pd_g +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/led_pd_y +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/led_pd_r +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/led_enc_p1_g +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/led_enc_p1_y +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/led_enc_p1_r +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/led_enc_p2_g +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/led_enc_p2_y +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/led_enc_p2_r +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/led_pof_g +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/led_pof_y +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/led_pof_r +add wave -noupdate -group {FPM top} /fire_pulse_manager_7_tb/iDUT/led_status +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/reset_n +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/clk +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/init +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/pd_in +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/inc_pos +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/dec_pos +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/abs_position +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/tx_data +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/avs_address +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/avs_write +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/avs_writedata +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/avs_read +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/avs_readdata +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/rd_event +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/wr_event +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/empty +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/full +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/tx_ready +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/rd_event_d +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/wr_event_i +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/symbol_valid +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/enable +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/toggle_sync +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/toggle_pd +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/add_keepalive +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/ovfl_err +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/init_d +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/init_gen +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/clear +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/pd_in_d +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/pd_gen +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/parity_bit +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/inject_error +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/inject_error_req +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/pd_event +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/pd_event_d +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/pd_event_dd +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/init_blocked +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/pd_event_ddd +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/delayed_pos +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/clr_fifo_lmax +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/delayed_pos_v +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/init_v +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/gray +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/bit_div +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/latched_pos +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/event_in_i +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/event_in +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/event_out +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/symbol +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/init_blk_cnt +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/keepalive_cnt +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/keepalive_period +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/init_blocked_period +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/fifo_level +add wave -noupdate -group POF_Tx /fire_pulse_manager_7_tb/iPOF_TX/fifo_level_max +add wave -noupdate -group {FPM Ctrl} /fire_pulse_manager_7_tb/iDUT/iCTRL/reset_n +add wave -noupdate -group {FPM Ctrl} /fire_pulse_manager_7_tb/iDUT/iCTRL/clk +add wave -noupdate -group {FPM Ctrl} /fire_pulse_manager_7_tb/iDUT/iCTRL/src_sel +add wave -noupdate -group {FPM Ctrl} /fire_pulse_manager_7_tb/iDUT/iCTRL/uart_regen_bypass +add wave -noupdate -group {FPM Ctrl} /fire_pulse_manager_7_tb/iDUT/iCTRL/enable_rx +add wave -noupdate -group {FPM Ctrl} /fire_pulse_manager_7_tb/iDUT/iCTRL/error_rate_thres +add wave -noupdate -group {FPM Ctrl} /fire_pulse_manager_7_tb/iDUT/iCTRL/max_error_flag +add wave -noupdate -group {FPM Ctrl} /fire_pulse_manager_7_tb/iDUT/iCTRL/rx_watchdog +add wave -noupdate -group {FPM Ctrl} /fire_pulse_manager_7_tb/iDUT/iCTRL/rx_watchdog_en +add wave -noupdate -group {FPM Ctrl} /fire_pulse_manager_7_tb/iDUT/iCTRL/rx_watchdog_clr +add wave -noupdate -group {FPM Ctrl} /fire_pulse_manager_7_tb/iDUT/iCTRL/parity_err_cnt +add wave -noupdate -group {FPM Ctrl} /fire_pulse_manager_7_tb/iDUT/iCTRL/skip_pos_cnt +add wave -noupdate -group {FPM Ctrl} /fire_pulse_manager_7_tb/iDUT/iCTRL/mon_point_src +add wave -noupdate -group {FPM Ctrl} /fire_pulse_manager_7_tb/iDUT/iCTRL/mon_points +add wave -noupdate -group {FPM Ctrl} /fire_pulse_manager_7_tb/iDUT/iCTRL/coarse_time +add wave -noupdate -group {FPM Ctrl} /fire_pulse_manager_7_tb/iDUT/iCTRL/fine_time +add wave -noupdate -group {FPM Ctrl} /fire_pulse_manager_7_tb/iDUT/iCTRL/one_pps +add wave -noupdate -group {FPM Ctrl} /fire_pulse_manager_7_tb/iDUT/iCTRL/dw_src +add wave -noupdate -group {FPM Ctrl} /fire_pulse_manager_7_tb/iDUT/iCTRL/dw_pulse_width +add wave -noupdate -group {FPM Ctrl} /fire_pulse_manager_7_tb/iDUT/iCTRL/ins_fpm_irq_0 +add wave -noupdate -group {FPM Ctrl} /fire_pulse_manager_7_tb/iDUT/iCTRL/avs_address +add wave -noupdate -group {FPM Ctrl} /fire_pulse_manager_7_tb/iDUT/iCTRL/avs_write +add wave -noupdate -group {FPM Ctrl} /fire_pulse_manager_7_tb/iDUT/iCTRL/avs_writedata +add wave -noupdate -group {FPM Ctrl} /fire_pulse_manager_7_tb/iDUT/iCTRL/avs_read +add wave -noupdate -group {FPM Ctrl} /fire_pulse_manager_7_tb/iDUT/iCTRL/avs_readdata +add wave -noupdate -group {FPM Ctrl} /fire_pulse_manager_7_tb/iDUT/iCTRL/enable_rx_i +add wave -noupdate -group {FPM Ctrl} /fire_pulse_manager_7_tb/iDUT/iCTRL/fine_time_wrap +add wave -noupdate -group {FPM Ctrl} /fire_pulse_manager_7_tb/iDUT/iCTRL/time_ld_en +add wave -noupdate -group {FPM Ctrl} /fire_pulse_manager_7_tb/iDUT/iCTRL/rx_watchdog_en_i +add wave -noupdate -group {FPM Ctrl} /fire_pulse_manager_7_tb/iDUT/iCTRL/rx_watchdog_clr_i +add wave -noupdate -group {FPM Ctrl} /fire_pulse_manager_7_tb/iDUT/iCTRL/uart_regen_bypass_i +add wave -noupdate -group {FPM Ctrl} /fire_pulse_manager_7_tb/iDUT/iCTRL/fpm_init_start +add wave -noupdate -group {FPM Ctrl} /fire_pulse_manager_7_tb/iDUT/iCTRL/fpm_init_done +add wave -noupdate -group {FPM Ctrl} /fire_pulse_manager_7_tb/iDUT/iCTRL/irq +add wave -noupdate -group {FPM Ctrl} /fire_pulse_manager_7_tb/iDUT/iCTRL/irq_src +add wave -noupdate -group {FPM Ctrl} /fire_pulse_manager_7_tb/iDUT/iCTRL/irq_src_d +add wave -noupdate -group {FPM Ctrl} /fire_pulse_manager_7_tb/iDUT/iCTRL/irq_en +add wave -noupdate -group {FPM Ctrl} /fire_pulse_manager_7_tb/iDUT/iCTRL/irq_mask +add wave -noupdate -group {FPM Ctrl} /fire_pulse_manager_7_tb/iDUT/iCTRL/irq_val +add wave -noupdate -group {FPM Ctrl} /fire_pulse_manager_7_tb/iDUT/iCTRL/irq_clr +add wave -noupdate -group {FPM Ctrl} /fire_pulse_manager_7_tb/iDUT/iCTRL/src_sel_i +add wave -noupdate -group {FPM Ctrl} /fire_pulse_manager_7_tb/iDUT/iCTRL/dw_src_i +add wave -noupdate -group {FPM Ctrl} /fire_pulse_manager_7_tb/iDUT/iCTRL/mp_sel0 +add wave -noupdate -group {FPM Ctrl} /fire_pulse_manager_7_tb/iDUT/iCTRL/mp_sel1 +add wave -noupdate -group {FPM Ctrl} /fire_pulse_manager_7_tb/iDUT/iCTRL/mp_sel2 +add wave -noupdate -group {FPM Ctrl} /fire_pulse_manager_7_tb/iDUT/iCTRL/mp_sel3 +add wave -noupdate -group {FPM Ctrl} /fire_pulse_manager_7_tb/iDUT/iCTRL/error_rate_thres_i +add wave -noupdate -group {FPM Ctrl} /fire_pulse_manager_7_tb/iDUT/iCTRL/dw_pulse_width_i +add wave -noupdate -group {FPM Ctrl} /fire_pulse_manager_7_tb/iDUT/iCTRL/fine_time_init +add wave -noupdate -group {FPM Ctrl} /fire_pulse_manager_7_tb/iDUT/iCTRL/fine_time_i +add wave -noupdate -group {FPM Ctrl} /fire_pulse_manager_7_tb/iDUT/iCTRL/coarse_time_init +add wave -noupdate -group {FPM Ctrl} /fire_pulse_manager_7_tb/iDUT/iCTRL/coarse_time_i +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/clk +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/reset_n +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/init +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/avs_address +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/avs_write +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/avs_writedata +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/avs_read +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/avs_readdata +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/rs422_pd +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/rs422_p1 +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/rs422_p2 +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/rs422_zp +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/ttl_pd +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/ttl_pd_npn +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/ttl_p1 +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/ttl_p2 +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/ttl_zp +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/abs_position +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/pd_out +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/print_start +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/set_pos +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/inc_pos +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/dec_pos +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/filt_p1 +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/filt_p2 +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/filt_zp +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/filt_pd +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/init_i +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/ttl_pd_i +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/sel_ttl_npn +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/pd_mux +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/p1_mux +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/p2_mux +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/zp_mux +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/ems_init +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/pd_i +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/pd_re +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/pd_fe +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/p1_i +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/p1_re +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/p1_fe +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/p2_i +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/p2_re +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/p2_fe +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/zp_i +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/p1_re_i +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/p1_fe_i +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/p2_re_i +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/p2_fe_i +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/enc_ph1_en +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/enc_ph2_en +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/enc_rising_en +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/enc_falling_en +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/step_pos_i +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/step_neg_i +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/step_pos +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/step_neg +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/set_pos_i +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/set_abs_pos +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/wrap_pos +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/wrap_neg +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/inc_pos_i +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/dec_pos_i +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/ems_enable +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/pd_hyst_filt +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/set_pd_hyst_filt +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/pd_event +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/clr_pd_hyst_filt +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/sw_pos_step +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/sw_neg_step +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/pd_rising_en +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/pd_falling_en +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/sw_pd +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/pd +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/kickstart_pd +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/sw_clr_pd_hyst_filt +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/ld_filt_cfg_pd +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/ld_filt_cfg_zp +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/ld_filt_cfg_p1 +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/ld_filt_cfg_p2 +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/switch_pos_neg_inc +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/step_pos_ii +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/step_neg_ii +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/enc_enable +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/enc_enable_i +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/pd_enable +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/pd_enable_i +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/wrap_pos_i +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/wrap_neg_i +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/use_multiplier +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/m_step_pos +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/m_step_neg +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/step_pos_retimed +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/step_neg_retimed +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/init_mult +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/enable_mult +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/enc_sel +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/pd_sel +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/mult_sel +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/pd_delay_line +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/enc_cnt +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/enc_divide +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/filt_order +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/filt_hyst +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/avg_steps +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/pd_hyst_val +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/pd_hyst_pos_cnt +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/pd_hyst_neg_cnt +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/hw_pd_cnt +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/total_pd_cnt +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/delta_init +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/time_out +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/abs_pos_i +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/abs_pos_init +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/abs_pos_in +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/abs_pos_vel +add wave -noupdate -group EMS /fire_pulse_manager_7_tb/iDUT/gEMS/iEMS/delta_t +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/clk +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/reset_n +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/init +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/pd_in +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/abs_position +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/enc_vel +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/enc_speed_meas_w +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/dp_dir +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/fire_req_vec +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/start_of_image_vec +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/filtered_pd +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/ch_pd +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/ch_mask +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/raw_fire_req +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/enc_pulse +add wave -noupdate -group PG-0 -radix hexadecimal /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/avs_address +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/avs_write +add wave -noupdate -group PG-0 -radix hexadecimal /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/avs_writedata +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/avs_read +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/avs_readdata +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/init_de +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/init_qd +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/enable +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/loc_pd +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/pd_queue_error +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/ch_ctrl_start_req +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/pd_pulse +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/filt_pd +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/filt_pd_d +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/ch_ctrl_write +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/ch_ctrl_read +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/ch_ctrl_busy +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/enable_i +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/ch_mask_i +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/bypass_ch_ctrl +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/bypass_delay_equal +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/div_pulse +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/gated_pulse +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/retimed_pulse +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/avs_write_i +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/avs_read_d +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/avs_read_i +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/de_queue_error +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/cnt_dir +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/dp_dir_i +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/ch_ctrl_start_req_i +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/set_first_pd +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/dp_dir_d +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/loc_pd_d +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/loc_pd_dd +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/start_img_req +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/start_img_req_d +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/start_img +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/start_img_d +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/start_img_dd +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/fire_enable +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/img_completed +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/sw_ctrl_dp_dir +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/enable_out +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/ch_ctrl_start_req_d +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/add_img_size +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/add_img_size_d +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/abort_fire +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/ch_ctrl_csr_write +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/ch_ctrl_csr_read +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/frac_div_en_i +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/upd_max_pos +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/upd_min_pos +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/frac_div_en +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/gen_filt_pd +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/upd_max_pos_i +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/upd_min_pos_i +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/dir_change +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/first_pd +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/pd_in_d +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/filt_pd_i +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/abs_pos_lsb +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/ch_ctrl_start_req_ii +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/prevent_div_restart +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/rst_jitter +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/abs_position +add wave -noupdate -group PG-0 -radix unsigned /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/subpix_phase_cnt +add wave -noupdate -group PG-0 -radix unsigned /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/subpixel_phase_num +add wave -noupdate -group PG-0 -radix hexadecimal /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/subpix_phase +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/rst_diag_regs +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/fire_req +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/start_of_image +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/new_pixel +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/mid_cross +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/mid_crossed +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/zero_cross +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/close_to_zero +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/close_to_mid +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/div_pulse_i +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/spitting_enable +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/spit_pulse +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/seq_bus_valid +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/spit_nco_msb +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/wh_apply_corr_en +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/wh_error_meas_avail +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/wh_corr_ready +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/wh_error_meas_started +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/init_wh +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/wh_meas_event +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/wh_img_end +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/first_img_started +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/tof_lut_wr_en +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/tof_comp_enable +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/tof_saturation +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/tof_sat_flag +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/wh_apply_corr_en_d +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/wh_corr_start +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/wh_skip_corr +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/wh_img_2nd_half +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/wh_img_2nd_half_d +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/selected_pulse +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/selected_pulse_d +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/clr_pd_queue +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/zero_gap_mode +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/start_image_flag +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/use_ch_offset_dir1 +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/add_ppc_regs +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/add_tof_comp_regs +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/add_delay_eq_reg +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/add_diag_reg +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/abs_pos_msb_old +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/ch_ctrl_csr_addr +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/ch_ctrl_trigger_in +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/wh_corr_ready_v +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/avs_addr +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/init_v +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/ch_ctrl_start_addr +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/bpe_top +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/ch_ctrl_address +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/tof_lut_wr_addr +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/tof_lut_addr +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/wh_rotat_cnt +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/gnd_16 +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/wh_loop_filt_tot +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/wh_loop_filt_delta +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/ch_delay +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/ch_delay_i +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/enc_speed_norm_coeff +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/tof_lut_wr_data +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/tof_lut_wr_q +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/tof_lut_comp +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/tof_lut_comp_i +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/pd_cnt +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/enc_speed_meas_w_i +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/enc_vel_i +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/img_size +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/pixel_cnt +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/ch_ctrl_vector_out +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/wh_skip_corr_thres +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/wh_img_pixel_cnt +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/wh_image_pixel_len +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/basic_pos_error_sat +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/fire_req_cnt +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/norm_enc_vel +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/ch_offset +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/avs_readdata_i +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/ch_ctrl_writedata +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/ch_ctrl_readdata +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/ch_ctrl_csr_writedata +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/ch_ctrl_csr_readdata +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/ch_offset_dir0 +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/ch_offset_dir1 +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/abs_pos_max +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/abs_pos_min +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/last_pd_pos +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/basic_pos_error +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/seq_bus_data +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/spit_nco +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/spit_nco_inc +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/start_pos +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/abs_pos_d +add wave -noupdate -group PG-0 -radix hexadecimal /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/subpix_phase +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/wh_pos_err_2_corr +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/wh_pos_err_max +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/wh_pos_err_min +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/wh_pos_err +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/wh_pos_err_curr +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/wh_pos_err_old +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/wh_pos_err_abs +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/wh_tot_err +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/wh_delta_err +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/div_ratio +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/div_ratio_i +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/div_ratio_corr +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/div_ratio_corr_new +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/wh_loop_err_delta +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/wh_loop_err_tot +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/pos_error +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/wh_loop_err +add wave -noupdate -group PG-0 /fire_pulse_manager_7_tb/iDUT/pulse_generator_g(0)/iCH_PG/div_ratio_corr_ext +add wave -noupdate /fire_pulse_manager_7_tb/dut_pof_rx +add wave -noupdate /fire_pulse_manager_7_tb/dut_pof_tx +add wave -noupdate /fire_pulse_manager_7_tb/pof_tx_to_DUT_tx_data +add wave -noupdate /fire_pulse_manager_7_tb/sel_slave_DUT +add wave -noupdate /fire_pulse_manager_7_tb/sel_slave_TB_POFTX +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/reset_n +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/clk +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/init +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/init_done +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/pd_in +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/print_start +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/pof_protocol_version +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/inc_pos +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/dec_pos +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/abs_position +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/tx_data +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/avs_address +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/avs_write +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/avs_writedata +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/avs_read +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/avs_readdata +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/rd_event +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/wr_event +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/empty +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/full +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/tx_ready +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/rd_event_d +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/wr_event_i +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/symbol_valid +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/enable +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/toggle_sync +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/toggle_pd +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/add_keepalive +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/ovfl_err +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/init_d +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/init_gen +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/clear +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/pd_in_d +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/pd_gen +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/parity_bit +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/inject_error +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/inject_error_req +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/pd_event +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/pd_event_d +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/pd_event_dd +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/init_blocked +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/pd_event_ddd +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/delayed_pos +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/clr_fifo_lmax +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/print_start_en +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/print_start_src +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/print_start_sw +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/print_start_val +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/print_start_val_d +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/print_start_event +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/print_start_event_d +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/print_start_gen +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/delayed_pos_v +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/init_v +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/gray +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/bit_div +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/latched_pos +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/event_in_i +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/event_in +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/event_out +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/symbol +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/init_blk_cnt +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/keepalive_cnt +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/keepalive_period +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/init_blocked_period +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/fifo_level +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/fifo_level_max +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/tx_data_0 +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/tx_data_1 +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/tx_ready_0 +add wave -noupdate -expand -group DUT_POF_TX /fire_pulse_manager_7_tb/iDUT/gPOF_TX/iPOF_TX/tx_ready_1 +TreeUpdate [SetDefaultTree] +WaveRestoreCursors {{Cursor 1} {2132125000 ps} 0} {{Cursor 2} {2134795000 ps} 0} +quietly wave cursor active 2 +configure wave -namecolwidth 433 +configure wave -valuecolwidth 100 +configure wave -justifyvalue left +configure wave -signalnamewidth 0 +configure wave -snapdistance 10 +configure wave -datasetprefix 0 +configure wave -rowmargin 4 +configure wave -childrowmargin 2 +configure wave -gridoffset 0 +configure wave -gridperiod 1 +configure wave -griddelta 40 +configure wave -timeline 0 +configure wave -timelineunits ps +update +WaveRestoreZoom {2120726423 ps} {2154724926 ps} diff --git a/generic_ip/fire_pulse_manager/8/sim/wave_fpm_one.do b/generic_ip/fire_pulse_manager/8/sim/wave_fpm_one.do new file mode 100644 index 0000000..2c8ea19 --- /dev/null +++ b/generic_ip/fire_pulse_manager/8/sim/wave_fpm_one.do @@ -0,0 +1,89 @@ +onerror {resume} +quietly WaveActivateNextPane {} 0 +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/ch_offset +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/ch_fire_pulse +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/ch_start_of_image +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/reset_n +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/clk +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/rx_clk +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/dut_pof_tx +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/dut_pof_rx +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/fire_pulse +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/start_of_image +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/avs_address +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/avs_write +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/avs_writedata +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/avs_read +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/avs_readdata +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/tb_pof_tx_init_tx +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/inc_pos +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/dec_pos +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/abs_position +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/pof_tx_to_DUT_tx_data +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/enc_p1 +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/enc_p2 +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/pd +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/seb_epd_enc_p1 +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/seb_epd_enc_p2 +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/seb_epd_pd +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/emul_address +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/emul_write +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/emul_writedata +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/emul_read +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/emul_readdata +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/emul_pos +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/enc_dir +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/swathe_cnt +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/half_swathe_cnt +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/swathe_pos +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/end_of_swathe +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/test_completed +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/running +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/configuring +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/passed +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/failed +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/stimuli_completed +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/registers_read +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/reprogram_offset +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/avs_m +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/avs_s +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/sel_slave_DUT +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/sel_slave_TB_POFTX +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/emul_s +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/emul_m +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/pd_cnt +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/fp_cnt +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/loc_fp_cnt +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/rst_fp_cnt +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/ch_pulse_out +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/ch_pulse_out_d +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/ch_start_of_img +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/run_dw +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/dw +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/dw_d +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/dw_cnt +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/input_mode +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/ext_pulse +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/ext_pulse_enable +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/fpm_abs_pos_out +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/fpm_print_start_rx +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/tb_pof_tx_print_start +add wave -noupdate -group TB /fire_pulse_manager_7_one_tb/tb_pof_tx_init_done +TreeUpdate [SetDefaultTree] +WaveRestoreCursors {{Cursor 1} {2132125000 ps} 0} {{Cursor 2} {2134795000 ps} 0} +quietly wave cursor active 2 +configure wave -namecolwidth 433 +configure wave -valuecolwidth 100 +configure wave -justifyvalue left +configure wave -signalnamewidth 0 +configure wave -snapdistance 10 +configure wave -datasetprefix 0 +configure wave -rowmargin 4 +configure wave -childrowmargin 2 +configure wave -gridoffset 0 +configure wave -gridperiod 1 +configure wave -griddelta 40 +configure wave -timeline 0 +configure wave -timelineunits ps +update +WaveRestoreZoom {1088091423 ps} {1122089926 ps} diff --git a/generic_ip/fire_pulse_manager/8/sim/wave_led.do b/generic_ip/fire_pulse_manager/8/sim/wave_led.do new file mode 100644 index 0000000..b717ba6 --- /dev/null +++ b/generic_ip/fire_pulse_manager/8/sim/wave_led.do @@ -0,0 +1,103 @@ +onerror {resume} +quietly WaveActivateNextPane {} 0 +add wave -noupdate /led_tb/reset_n +add wave -noupdate /led_tb/clk +add wave -noupdate /led_tb/init +add wave -noupdate /led_tb/pd +add wave -noupdate /led_tb/enc_p1 +add wave -noupdate /led_tb/enc_p2 +add wave -noupdate /led_tb/pof +add wave -noupdate /led_tb/all_ok +add wave -noupdate /led_tb/led_pd_g +add wave -noupdate /led_tb/led_pd_y +add wave -noupdate /led_tb/led_pd_r +add wave -noupdate /led_tb/led_enc_p1_g +add wave -noupdate /led_tb/led_enc_p1_y +add wave -noupdate /led_tb/led_enc_p1_r +add wave -noupdate /led_tb/led_enc_p2_g +add wave -noupdate /led_tb/led_enc_p2_y +add wave -noupdate /led_tb/led_enc_p2_r +add wave -noupdate /led_tb/led_pof_g +add wave -noupdate /led_tb/led_pof_y +add wave -noupdate /led_tb/led_pof_r +add wave -noupdate /led_tb/setup +add wave -noupdate /led_tb/running +add wave -noupdate /led_tb/passed +add wave -noupdate /led_tb/failed +add wave -noupdate /led_tb/test_timeout +add wave -noupdate /led_tb/test_completed +add wave -noupdate /led_tb/error_flag +add wave -noupdate /led_tb/iUUT/reset_n +add wave -noupdate /led_tb/iUUT/clk +add wave -noupdate /led_tb/iUUT/init +add wave -noupdate /led_tb/iUUT/pd +add wave -noupdate /led_tb/iUUT/enc_p1 +add wave -noupdate /led_tb/iUUT/enc_p2 +add wave -noupdate /led_tb/iUUT/pof +add wave -noupdate /led_tb/iUUT/all_ok +add wave -noupdate /led_tb/iUUT/led_pd_g +add wave -noupdate /led_tb/iUUT/led_pd_y +add wave -noupdate /led_tb/iUUT/led_pd_r +add wave -noupdate /led_tb/iUUT/led_enc_p1_g +add wave -noupdate /led_tb/iUUT/led_enc_p1_y +add wave -noupdate /led_tb/iUUT/led_enc_p1_r +add wave -noupdate /led_tb/iUUT/led_enc_p2_g +add wave -noupdate /led_tb/iUUT/led_enc_p2_y +add wave -noupdate /led_tb/iUUT/led_enc_p2_r +add wave -noupdate /led_tb/iUUT/led_pof_g +add wave -noupdate /led_tb/iUUT/led_pof_y +add wave -noupdate /led_tb/iUUT/led_pof_r +add wave -noupdate /led_tb/iUUT/pd_d +add wave -noupdate /led_tb/iUUT/enc_p1_d +add wave -noupdate /led_tb/iUUT/enc_p2_d +add wave -noupdate /led_tb/iUUT/one_ms_pulse +add wave -noupdate /led_tb/iUUT/pd_event +add wave -noupdate /led_tb/iUUT/pd_cnt_zero_flag +add wave -noupdate /led_tb/iUUT/rst_pd_green +add wave -noupdate /led_tb/iUUT/pd_red +add wave -noupdate /led_tb/iUUT/pd_green +add wave -noupdate /led_tb/iUUT/p1_event +add wave -noupdate /led_tb/iUUT/p2_event +add wave -noupdate /led_tb/iUUT/p1_cnt_zero_flag +add wave -noupdate /led_tb/iUUT/p2_cnt_zero_flag +add wave -noupdate /led_tb/iUUT/rst_p1_green +add wave -noupdate /led_tb/iUUT/rst_p2_green +add wave -noupdate /led_tb/iUUT/p1_red +add wave -noupdate /led_tb/iUUT/p2_red +add wave -noupdate /led_tb/iUUT/p1_green +add wave -noupdate /led_tb/iUUT/p2_green +add wave -noupdate /led_tb/iUUT/pof_green +add wave -noupdate /led_tb/iUUT/rst_pof_green +add wave -noupdate /led_tb/iUUT/pof_d +add wave -noupdate /led_tb/iUUT/pof_event +add wave -noupdate /led_tb/iUUT/pof_cnt_zero_flag +add wave -noupdate /led_tb/iUUT/all_ok_d +add wave -noupdate /led_tb/iUUT/alert_cnt_zero_flag +add wave -noupdate /led_tb/iUUT/pd_active +add wave -noupdate /led_tb/iUUT/p1_active +add wave -noupdate /led_tb/iUUT/p2_active +add wave -noupdate /led_tb/iUUT/alert_led +add wave -noupdate -radix unsigned /led_tb/iUUT/pd_cnt +add wave -noupdate -radix unsigned /led_tb/iUUT/p1_cnt +add wave -noupdate -radix unsigned /led_tb/iUUT/p2_cnt +add wave -noupdate -radix unsigned /led_tb/iUUT/pof_cnt +add wave -noupdate -radix unsigned /led_tb/iUUT/alert_cnt +add wave -noupdate -radix unsigned /led_tb/iUUT/one_ms_cnt +TreeUpdate [SetDefaultTree] +WaveRestoreCursors {{Cursor 1} {510235000 ps} 0} +quietly wave cursor active 1 +configure wave -namecolwidth 238 +configure wave -valuecolwidth 137 +configure wave -justifyvalue left +configure wave -signalnamewidth 0 +configure wave -snapdistance 10 +configure wave -datasetprefix 0 +configure wave -rowmargin 4 +configure wave -childrowmargin 2 +configure wave -gridoffset 0 +configure wave -gridperiod 1 +configure wave -griddelta 40 +configure wave -timeline 0 +configure wave -timelineunits ps +update +WaveRestoreZoom {33524561308 ps} {49777259932 ps} diff --git a/generic_ip/fire_pulse_manager/8/src/epd_diagnostics_8.vhd b/generic_ip/fire_pulse_manager/8/src/epd_diagnostics_8.vhd new file mode 100644 index 0000000..7a0e7e1 --- /dev/null +++ b/generic_ip/fire_pulse_manager/8/src/epd_diagnostics_8.vhd @@ -0,0 +1,645 @@ +------------------------------------------------------------------------------- +-- Title : epd diagnostic block +-- Project : Fire Pulse Manager +------------------------------------------------------------------------------- +-- File : epd_diagnostics_8.vhd +-- Author : Gianmarco Girau +-- Company : Global Inkjet Systems +-- Created : 2016-08-02 +-- Last update: 2022-05-17 +-- SVN ID : Git +-- Standard : VHDL'2008 +------------------------------------------------------------------------------- +-- Description: This block includes all the EPD (encoder/Product Detect) diagnostic +-- functionalities except the event logger. +------------------------------------------------------------------------------- +-- altera vhdl_input_version vhdl_2008 + +library ieee; +use ieee.std_logic_1164.all; +use ieee.numeric_std.all; + +entity epd_diagnostics_8 is + generic ( + DEVICE_FAMILY : string := "Cyclone V" + ); + port ( + clk : in std_logic; + reset_n : in std_logic := '1'; + -- External sync reset (via daisy-chain) + ext_diag_rst : in std_logic; + -- diagnostic inputs + rs422_phase0 : in std_logic; + rs422_phase1 : in std_logic; + rs422_zero_ph : in std_logic; + rs422_prod_det : in std_logic; + ttl_phase0 : in std_logic; + ttl_phase1 : in std_logic; + ttl_zero_ph : in std_logic; + ttl_prod_det : in std_logic; + ttl_prod_det_npn : in std_logic; + filt_phase0 : in std_logic; + filt_phase1 : in std_logic; + filt_zero_ph : in std_logic; + filt_prod_det : in std_logic; + enc_out : in std_logic; + pd_out : in std_logic; + pos_step : in std_logic; + neg_step : in std_logic; + drop_watch : in std_logic; + fire_req : in std_logic; + -- local timer + fine_time : in std_logic_vector(27 downto 0); + coarse_time : in std_logic_vector(31 downto 0); + -- Absolute Position + abs_position : out std_logic_vector(31 downto 0); + -- Interrupt Senders + ins_diag_irq_0 : out std_logic; + ins_diag_irq_1 : out std_logic; + ins_diag_irq_2 : out std_logic; + -- Avalon MM Interface + avs_address : in std_logic_vector(5 downto 0); + avs_write : in std_logic; + avs_writedata : in std_logic_vector(31 downto 0); + avs_read : in std_logic; + avs_readdatavalid : out std_logic; + avs_readdata : out std_logic_vector(31 downto 0)); +end entity epd_diagnostics_8; + +architecture rtl of epd_diagnostics_8 is + + -- signals + type fsm_status_t is (idle, wait_ph1_ris, wait_ph0_ris); + signal fsm_status_curr, fsm_status_next : fsm_status_t; + -- + signal filt_phase0_d, filt_phase1_d, filt_zero_ph_d, filt_prod_det_d : std_logic; + signal enc_out_d, pd_out_d, filt_phase0_p, filt_phase1_p, init_i : std_logic; + signal filt_zero_ph_p, filt_prod_det_p, enc_out_p, pd_out_p : std_logic; + signal init, rst_counters_i, rst_counters, rst_measur_i, rst_measur : std_logic; + signal rst_dir, rst_dir_i, enable_diff_measur, meas_enc_p : std_logic; + signal ph0_rising, ph0_falling, ph1_rising, ph1_falling : std_logic; + signal set_dir_forward, set_dir_backward, dir_pos_sat, dir_neg_sat : std_logic; + signal direction, direction_d, direction_change : std_logic; + signal sampling_time, fifo_rd_en, fifo_wr_en, fifo_full, fifo_error : std_logic; + signal rst_fifo_i, rst_fifo, rst_pos, rst_pos_i, avs_read_i : std_logic; + signal pd_fifo_error, pd_fifo_wr_en, pd_fifo_rd_en, pd_fifo_full : std_logic; + signal pd_p, pd_log_src, pd_fifo_alarm, enc_fifo_alarm : std_logic; + signal clr_pd_pos, pd_wd_en, pd_wd_alarm, rst_pd_fifo, rst_pd_fifo_i : std_logic; + signal fire_req_d, fire_req_p : std_logic; + signal rd_enc_fifo_pulse, rd_pd_fifo_pulse : std_logic; + -- + signal enable_diff_measur_cnt : std_logic_vector(1 downto 0); + signal irq_en, irq_clr, irq_src, irq_src_d : std_logic_vector(2 downto 0); + signal irq, irq_val, irq_mask, pd_data_sel : std_logic_vector(2 downto 0); + signal meas_enc_pulse : std_logic_vector(3 downto 0); + signal pd_fifo_usedw, pd_fifo_thres : std_logic_vector(7 downto 0); + signal fifo_thres, fifo_usedw : std_logic_vector(9 downto 0); + signal dir_cnt, dir_change_cnt : std_logic_vector(15 downto 0); + signal pos_dir_thres, neg_dir_thres : std_logic_vector(15 downto 0); + signal meas_pulse_cnt, meas_step : std_logic_vector(15 downto 0); + signal input_status : std_logic_vector(16 downto 0); + signal sampling_period, sampling_time_cnt : std_logic_vector(27 downto 0); + signal fine_time_l : std_logic_vector(27 downto 0); + signal filt_phase0_cnt, filt_phase1_cnt : std_logic_vector(31 downto 0); + signal filt_zero_ph_cnt, filt_prod_det_cnt : std_logic_vector(31 downto 0); + signal enc_out_cnt, pd_out_cnt : std_logic_vector(31 downto 0); + signal enc_delta_time, enc_delta_time_prev : std_logic_vector(31 downto 0); + signal enc_delta_time_cnt : std_logic_vector(31 downto 0); + signal enc_delta_time_min, enc_delta_time_max : std_logic_vector(31 downto 0); + signal fifo_d, fifo_q, pos_cnt : std_logic_vector(31 downto 0); + signal pd_fifo_d, pd_fifo_q : std_logic_vector(31 downto 0); + signal pd_pos, coarse_time_l, pd_wd_thres : std_logic_vector(31 downto 0); + signal pd_delta_pos, pd_delta_pos_abs : std_logic_vector(31 downto 0); + signal fire_req_cnt : std_logic_vector(31 downto 0); + +begin + + pInit : process(clk) + begin + if (clk = '1' and clk'event) then + init <= init_i or ext_diag_rst; + end if; + end process pInit; + + ----------------------------------------------------------------------------- + -- Input Status + ----------------------------------------------------------------------------- + + pInputStatus : process(clk) + begin + if (clk = '1' and clk'event) then + input_status(0) <= rs422_phase0; + input_status(1) <= rs422_phase1; + input_status(2) <= rs422_zero_ph; + input_status(3) <= rs422_prod_det; + input_status(4) <= ttl_phase0; + input_status(5) <= ttl_phase1; + input_status(6) <= ttl_zero_ph; + input_status(7) <= ttl_prod_det; + input_status(8) <= ttl_prod_det_npn; + input_status(9) <= filt_phase0; + input_status(10) <= filt_phase1; + input_status(11) <= filt_zero_ph; + input_status(12) <= filt_prod_det; + input_status(13) <= enc_out; + input_status(14) <= pd_out; + input_status(15) <= drop_watch; + input_status(16) <= fire_req; + end if; + end process pInputStatus; + + ----------------------------------------------------------------------------- + -- Edge detection and counting + ----------------------------------------------------------------------------- + + pEdgeDetect_Cnt : process(clk) + begin + if (clk = '1' and clk'event) then + filt_phase0_d <= filt_phase0; + filt_phase1_d <= filt_phase1; + filt_zero_ph_d <= filt_zero_ph; + filt_prod_det_d <= filt_prod_det; + enc_out_d <= enc_out; + pd_out_d <= pd_out; + fire_req_d <= fire_req; + if (rst_counters = '1') then + filt_phase0_cnt <= (others => '0'); + elsif (filt_phase0_p = '1') then + filt_phase0_cnt <= std_logic_vector(unsigned(filt_phase0_cnt) + 1); + end if; + if (rst_counters = '1') then + filt_phase1_cnt <= (others => '0'); + elsif (filt_phase1_p = '1') then + filt_phase1_cnt <= std_logic_vector(unsigned(filt_phase1_cnt) + 1); + end if; + if (rst_counters = '1') then + filt_zero_ph_cnt <= (others => '0'); + elsif (filt_zero_ph_p = '1') then + filt_zero_ph_cnt <= std_logic_vector(unsigned(filt_zero_ph_cnt) + 1); + end if; + if (rst_counters = '1') then + filt_prod_det_cnt <= (others => '0'); + elsif (filt_prod_det_p = '1') then + filt_prod_det_cnt <= std_logic_vector(unsigned(filt_prod_det_cnt) + 1); + end if; + if (rst_counters = '1') then + enc_out_cnt <= (others => '0'); + elsif (enc_out_p = '1') then + enc_out_cnt <= std_logic_vector(unsigned(enc_out_cnt) + 1); + end if; + if (rst_counters = '1') then + pd_out_cnt <= (others => '0'); + elsif (pd_out_p = '1') then + pd_out_cnt <= std_logic_vector(unsigned(pd_out_cnt) + 1); + end if; + if (rst_counters = '1') then + fire_req_cnt <= (others => '0'); + elsif (fire_req_p = '1') then + fire_req_cnt <= std_logic_vector(unsigned(fire_req_cnt) + 1); + end if; + end if; + end process pEdgeDetect_Cnt; + + filt_phase0_p <= filt_phase0 and not filt_phase0_d; + filt_phase1_p <= filt_phase1 and not filt_phase1_d; + filt_zero_ph_p <= filt_zero_ph and not filt_zero_ph_d; + filt_prod_det_p <= filt_prod_det and not filt_prod_det_d; + enc_out_p <= enc_out and not enc_out_d; + pd_out_p <= pd_out and not pd_out_d; + fire_req_p <= fire_req and not fire_req_d; + + rst_counters <= rst_counters_i or init; + + ----------------------------------------------------------------------------- + -- Speed and acceleration measurements + ----------------------------------------------------------------------------- + + pMeasure : process(clk) + begin + if (clk = '1' and clk'event) then + if (rst_measur = '1' or meas_enc_p = '1') then + meas_pulse_cnt <= (others => '0'); + elsif (enc_out_d = '1') then + meas_pulse_cnt <= std_logic_vector(unsigned(meas_pulse_cnt) + 1); + end if; + if (rst_measur = '1') then + meas_enc_pulse <= (others => '0'); + else + meas_enc_pulse <= meas_enc_pulse(meas_enc_pulse'high - 1 downto 0) & meas_enc_p; + end if; + if (rst_measur = '1' or meas_enc_pulse(0) = '1') then + enc_delta_time_cnt <= (others => '0'); + else + enc_delta_time_cnt <= std_logic_vector(unsigned(enc_delta_time_cnt) + 1); + end if; + if (rst_measur = '1') then + enc_delta_time <= (others => '0'); + enc_delta_time_prev <= (others => '0'); + elsif (meas_enc_pulse(0) = '1') then + enc_delta_time <= enc_delta_time_cnt; + enc_delta_time_prev <= enc_delta_time; + end if; + if (rst_measur = '1' or rst_counters = '1') then + enable_diff_measur_cnt <= (others => '0'); + elsif (meas_enc_p = '1') then + enable_diff_measur_cnt <= std_logic_vector(unsigned(enable_diff_measur_cnt) + 1); + end if; + if (rst_measur = '1' or rst_counters = '1') then + enable_diff_measur <= '0'; + elsif (enable_diff_measur_cnt = "11") then + enable_diff_measur <= '1'; + end if; + if (enable_diff_measur = '0') then + enc_delta_time_min <= (others => '1'); + elsif (meas_enc_pulse(2) = '1' and unsigned(enc_delta_time) < unsigned(enc_delta_time_min)) then + enc_delta_time_min <= enc_delta_time; + end if; + if (enable_diff_measur = '0') then + enc_delta_time_max <= (others => '0'); + elsif (meas_enc_pulse(2) = '1' and unsigned(enc_delta_time) > unsigned(enc_delta_time_max)) then + enc_delta_time_max <= enc_delta_time; + end if; + end if; + end process pMeasure; + + meas_enc_p <= '1' when enc_out_p = '1' and unsigned(meas_pulse_cnt) = unsigned(meas_step) else '0'; + + rst_measur <= rst_measur_i or init; + + ----------------------------------------------------------------------------- + -- Direction detection & Position Tracking + ----------------------------------------------------------------------------- + + -- Direction is detected by checking the order of rising and falling edged + -- between phase-0 and phase-1. + -- Forward direction => Phase-0 is anticipated w.r.t. Phase-1 + -- Backward direction => Phase-0 is delayed w.r.t. Phase-1 + + ph0_rising <= filt_phase0_p; + ph0_falling <= not filt_phase0 and filt_phase0_d; + ph1_rising <= filt_phase1_p; + ph1_falling <= not filt_phase1 and filt_phase1_d; + + rst_dir <= rst_dir_i or init; + + -- Use a FSM to detect the sequence of events: + -- FSM Status Register + pFSM_SR : process(clk) + begin + if (clk = '1' and clk'event) then + if (rst_dir = '1') then + fsm_status_curr <= idle; + else + fsm_status_curr <= fsm_status_next; + end if; + end if; + end process pFSM_SR; + + -- FSM Combinational Logic + pFSM_CL : process(fsm_status_curr, ph0_rising, ph0_falling, ph1_rising, ph1_falling) + begin + -- default assignments + set_dir_forward <= '0'; + set_dir_backward <= '0'; + -- + fsm_status_next <= fsm_status_curr; + + case fsm_status_curr is + when idle => + if (ph0_rising = '1') then + fsm_status_next <= wait_ph1_ris; + elsif (ph1_rising = '1') then + fsm_status_next <= wait_ph0_ris; + end if; + + when wait_ph1_ris => + if (ph1_rising = '1') then + set_dir_forward <= '1'; + fsm_status_next <= idle; + elsif (ph0_falling = '1') then + fsm_status_next <= idle; + end if; + + when wait_ph0_ris => + if (ph0_rising = '1') then + set_dir_backward <= '1'; + fsm_status_next <= idle; + elsif (ph1_falling = '1') then + fsm_status_next <= idle; + end if; + + when others => null; + end case; + end process pFSM_CL; + + pDirRegs : process(clk) + begin + if (clk = '1' and clk'event) then + if (rst_dir = '1') then + dir_cnt <= (others => '0'); + elsif (set_dir_forward = '1' and dir_pos_sat = '0') then + dir_cnt <= std_logic_vector(signed(dir_cnt) + 1); + elsif (set_dir_backward = '1' and dir_neg_sat = '0') then + dir_cnt <= std_logic_vector(signed(dir_cnt) - 1); + end if; + direction_d <= direction; + if (rst_dir = '1') then + dir_change_cnt <= (others => '0'); + elsif (direction_change = '1') then + dir_change_cnt <= std_logic_vector(unsigned(dir_change_cnt) + 1); + end if; + end if; + end process pDirRegs; + + direction <= dir_cnt(dir_cnt'high); + direction_change <= direction xor direction_d; + + -- Positive/Negative saturation for the direction counter + dir_pos_sat <= '1' when signed(dir_cnt) > signed(pos_dir_thres) else '0'; + dir_neg_sat <= '1' when signed(dir_cnt) < signed(neg_dir_thres) else '0'; + + -- Position Tracking + pPOS_TRACK : process(clk) + begin + if (clk = '1' and clk'event) then + if (rst_pos = '1') then + pos_cnt <= (others => '0'); + elsif (pos_step = '1') then + pos_cnt <= std_logic_vector(signed(pos_cnt) + 1); + elsif (neg_step = '1') then + pos_cnt <= std_logic_vector(signed(pos_cnt) - 1); + end if; + abs_position <= pos_cnt; + end if; + end process pPOS_TRACK; + + rst_pos <= init or rst_pos_i; + + ----------------------------------------------------------------------------- + -- PD logging + ----------------------------------------------------------------------------- + + pPD_log : process(clk) + begin + if (clk = '1' and clk'event) then + if (init = '1') then + pd_fifo_error <= '0'; + elsif (pd_fifo_wr_en = '1' and pd_fifo_full = '1') then + pd_fifo_error <= '1'; + end if; + if (init = '0' and pd_p = '1') then + pd_data_sel <= "001"; + else + pd_data_sel <= pd_data_sel(1 downto 0) & '0'; + end if; + if (init = '1') then + fine_time_l <= (others => '0'); + coarse_time_l <= (others => '0'); + pd_pos <= (others => '0'); + elsif (pd_p = '1') then + fine_time_l <= fine_time; + coarse_time_l <= coarse_time; + pd_pos <= pos_cnt; + end if; + end if; + end process pPD_log; + + pd_p <= pd_out_p when pd_log_src = '1' else filt_prod_det_p; + + iPD_log_fifo : entity work.sync_fifo + generic map( + DEVICE_FAMILY => DEVICE_FAMILY, + DATA_WIDTH => 32, + DEPTH => 256, + SHOWAHEAD => "OFF", + REGISTER_OUTPUT => "OFF" + ) + port map ( + clk => clk, + wrdata => pd_fifo_d, + rdreq => pd_fifo_rd_en, + sclr => rst_pd_fifo, + wrreq => pd_fifo_wr_en, + empty => open, + full => pd_fifo_full, + rddata => pd_fifo_q, + usedw => pd_fifo_usedw); + + pd_fifo_rd_en <= rd_pd_fifo_pulse; + + pd_fifo_alarm <= '1' when unsigned(pd_fifo_usedw) >= unsigned(pd_fifo_thres) else '0'; + + -- FIFO write logic + pd_fifo_wr_en <= pd_data_sel(2) or pd_data_sel(1) or pd_data_sel(0); + + -- select the input for the pd fifo + with pd_data_sel select + pd_fifo_d <= + X"0" & fine_time_l when "001", + coarse_time_l when "010", + pd_pos when others; + + rst_pd_fifo <= rst_pd_fifo_i or init; + + -- PD Positional Watch-Dog + pPD_WatchDog : process(clk) + begin + if (clk = '1') then + if (init = '1' or clr_pd_pos = '1' or filt_prod_det_p = '1') then + pd_delta_pos <= (others => '0'); + elsif (pos_step = '1') then + pd_delta_pos <= std_logic_vector(signed(pd_delta_pos) + 1); + elsif (neg_step = '1') then + pd_delta_pos <= std_logic_vector(signed(pd_delta_pos) - 1); + end if; + -- compare the absolute value of the delta position against the + -- threshold. Use the 1's complement to save some logic. + if (pd_wd_en = '1' and unsigned(pd_delta_pos_abs) > unsigned(pd_wd_thres)) then + pd_wd_alarm <= '1'; + else + pd_wd_alarm <= '0'; + end if; + end if; + end process pPD_WatchDog; + + pd_delta_pos_abs <= '0' & pd_delta_pos(30 downto 0) when pd_delta_pos(31) = '0' else '0' & not pd_delta_pos(30 downto 0); + + ----------------------------------------------------------------------------- + -- Encoder pulse count buffering (ACTUALLY NOW IS POSITION COUNT SAMPLING!!!) + ----------------------------------------------------------------------------- + + -- The encoder pulse count is periodically sampled. The samples are stored in + -- a dedicated FIFO and they can be used to generate a speed/acceleration + -- profile. => CHANGED: JUST using the position count, because it is more + -- it is independent of the encoder directionality settings + + pEncPulseSample : process(clk) + begin + if (clk = '1' and clk'event) then + if (rst_fifo = '1' or sampling_time = '1') then + sampling_time_cnt <= (others => '0'); + else + sampling_time_cnt <= std_logic_vector(unsigned(sampling_time_cnt) + 1); + end if; + if (rst_fifo = '1') then + fifo_error <= '0'; + elsif (fifo_wr_en = '1' and fifo_full = '1') then + fifo_error <= '1'; + end if; + fifo_wr_en <= sampling_time; + --fifo_d <= enc_out_cnt; + fifo_d <= pos_cnt; + end if; + end process pEncPulseSample; + + sampling_time <= '1' when unsigned(sampling_time_cnt) = unsigned(sampling_period) else '0'; + + iEncPulseFifo : entity work.sync_fifo + generic map( + DEVICE_FAMILY => DEVICE_FAMILY, + DATA_WIDTH => 32, + DEPTH => 256, + SHOWAHEAD => "OFF", + REGISTER_OUTPUT => "OFF" + ) + port map ( + clk => clk, + wrdata => fifo_d, + rdreq => fifo_rd_en, + sclr => rst_fifo, + wrreq => fifo_wr_en, + empty => open, + full => fifo_full, + rddata => fifo_q, + usedw => fifo_usedw); + + fifo_rd_en <= rd_enc_fifo_pulse; + + enc_fifo_alarm <= '1' when unsigned(fifo_usedw) >= unsigned(fifo_thres) else '0'; + + rst_fifo <= init or rst_fifo_i or rst_counters_i; + + ----------------------------------------------------------------------------- + -- IRQ generation and management + ----------------------------------------------------------------------------- + + pIRQ : process(reset_n, clk) + begin + if (reset_n = '0') then + ins_diag_irq_0 <= '0'; + ins_diag_irq_1 <= '0'; + ins_diag_irq_2 <= '0'; + irq <= "000"; + irq_src_d <= "000"; + elsif (clk = '1' and clk'event) then + irq_src_d <= irq_src; + for n in 0 to 2 loop + if (irq_clr(n) = '1') then + irq(n) <= '0'; + elsif (irq_en(n) = '1' and irq_src(n) = '1' and irq_src_d(n) = '0') then + irq(n) <= '1'; + end if; + end loop; -- n + ins_diag_irq_0 <= irq_val(0); + ins_diag_irq_1 <= irq_val(1); + ins_diag_irq_2 <= irq_val(2); + end if; + end process pIRQ; + + irq_val <= irq and not irq_mask; + irq_src <= pd_wd_alarm & pd_fifo_alarm & enc_fifo_alarm; + + ----------------------------------------------------------------------------- + -- C&S registers (Avalon-MM I/F) + ----------------------------------------------------------------------------- + + epd_diags_csr_regs_i : entity work.epd_diags_8_csr_regs + generic map( + ADDR_DECODE_WIDTH => 5 + ) + port map( + -- Clock and reset + clk => clk, + rst_n => reset_n, + + -- auto-generated + + -- Internal signal ports + init_init => init_i, + init_rst_counters => rst_counters_i, + init_rst_measur => rst_measur_i, + init_rst_dir => rst_dir_i, + init_rst_enc_fifo => rst_fifo_i, + init_rst_pos => rst_pos_i, + init_rst_pd_fifo => rst_pd_fifo_i, + delta_time_meas_step => meas_step, + dir_thres_pos_dir_thres => pos_dir_thres, + dir_thres_neg_dir_thres => neg_dir_thres, + enc_sampling_period => sampling_period, + enc_fifo_mng_w_irq_gen_thres => fifo_thres, + pd_fifo_mng_w_irq_gen_thres => pd_fifo_thres, + pd_fifo_mng_w_pd_log_src => pd_log_src, + pd_watchdog_ctrl_watchdog_en => pd_wd_en, + pd_watchdog_ctrl_watchdog_clr => clr_pd_pos, + pd_watchdog_thres => pd_wd_thres, + irq_mng_irq_en => irq_en, + irq_mng_irq_clr => irq_clr, + irq_mng_irq_mask => irq_mask, + rd_enc_fifo_pulse => rd_enc_fifo_pulse, + rd_enc_fifo => open, + rd_enc_fifo_in => '0', + rd_pd_fifo_pulse => rd_pd_fifo_pulse, + rd_pd_fifo => open, + rd_pd_fifo_in => '0', + input_status_rs422_p1 => input_status(0), + input_status_rs422_p2 => input_status(1), + input_status_rs422_zp => input_status(2), + input_status_rs422_pd => input_status(3), + input_status_ttl_p1 => input_status(4), + input_status_ttl_p2 => input_status(5), + input_status_ttl_zp => input_status(6), + input_status_ttl_pd_pnp => input_status(7), + input_status_ttl_pd_npn => input_status(8), + input_status_filt_p1 => input_status(9), + input_status_filt_p2 => input_status(10), + input_status_filt_zp => input_status(11), + input_status_filt_pd => input_status(12), + input_status_enc_pulse => input_status(13), + input_status_pd_out => input_status(14), + input_status_drop_watch => input_status(15), + input_status_fire_req => input_status(16), + phase1_counter => filt_phase0_cnt, + phase2_counter => filt_phase1_cnt, + zero_phase_counter => filt_zero_ph_cnt, + pd_counter => filt_prod_det_cnt, + enc_pulse_counter => enc_out_cnt, + pd_output_counter => pd_out_cnt, + fire_request_counter => fire_req_cnt, + delta_time_meas => enc_delta_time, + deltamin_time_meas => enc_delta_time_min, + deltamax_time_meas => enc_delta_time_max, + delta_time_prev_meas => enc_delta_time_prev, + abs_pos => pos_cnt, + dir_cnt_dir_cnt => dir_cnt, + dir_cnt_dir_change_cnt => dir_change_cnt, + enc_fifo_mng_r_fifo_level => fifo_usedw, + enc_fifo_mng_r_fifo_overflow => fifo_error, + enc_fifo_output => fifo_q, + pd_fifo_mng_r_fifo_level => pd_fifo_usedw, + pd_fifo_mng_r_fifo_overflow => pd_fifo_error, + pd_fifo_output => pd_fifo_q, + pd_watchdog_status => pd_wd_alarm, + irq_value => irq_val, + + -- end auto-generated + + -- Slave bus port + avs_address => avs_address(4 downto 0), + avs_write => avs_write, + avs_writedata => avs_writedata, + avs_read => avs_read, + avs_readdata => avs_readdata + + ); + +end architecture rtl; diff --git a/generic_ip/fire_pulse_manager/8/src/fire_pulse_8_pkg.vhd b/generic_ip/fire_pulse_manager/8/src/fire_pulse_8_pkg.vhd new file mode 100644 index 0000000..e5fcd05 --- /dev/null +++ b/generic_ip/fire_pulse_manager/8/src/fire_pulse_8_pkg.vhd @@ -0,0 +1,38 @@ +------------------------------------------------------------------------------- +-- Title : fire_pulse_pkg +-- Project : HMB/EMB/SMB +------------------------------------------------------------------------------- +-- File : fire_pulse_pkg.vhd +-- Author : Gianmarco Girau +-- Company : Global Inkjet Systems +-- Created : 2017-09-08 +-- Last update: 2020-04-17 +-- SVN ID : Git +-- Standard : VHDL'08 +------------------------------------------------------------------------------- +-- Description: +-- Package for fire_pulse_manager block +------------------------------------------------------------------------------- +-- altera vhdl_input_version vhdl_2008 + +library ieee; +use ieee.std_logic_1164.all; +use ieee.numeric_std.all; + +package fire_pulse_8_pkg is + + ----------------------------------------------------------------------------- + -- Inner block mapping + ----------------------------------------------------------------------------- + + constant BLK_SIZE : integer := 2048; + + constant FP_CTRL_ID : natural := 0; -- Block ID for the Fire-Pulse-Manager Controller + constant DIAG_BLK_ID : natural := 1; -- Block ID for the Diagnostic Block + constant LOG_BLK_ID : natural := 2; -- Block ID for the Event Logger + constant INT_ENC_ID : natural := 3; -- Block ID for the Internal Encoder Block + constant EMS_BLK_ID : natural := 4; -- Block ID for the EMS block + constant POF_BLK_ID : natural := 5; -- Block ID for the POF output interface + constant PG_CH_ID : natural := 6; -- Block ID for Pulse-Generator + +end package fire_pulse_8_pkg; diff --git a/generic_ip/fire_pulse_manager/8/src/fire_pulse_ctrl_8.vhd b/generic_ip/fire_pulse_manager/8/src/fire_pulse_ctrl_8.vhd new file mode 100644 index 0000000..d8c5804 --- /dev/null +++ b/generic_ip/fire_pulse_manager/8/src/fire_pulse_ctrl_8.vhd @@ -0,0 +1,245 @@ +------------------------------------------------------------------------------- +-- Title : fire_pulse_ctrl +-- Project : HMB/EMB/SMB +------------------------------------------------------------------------------- +-- File : fire_pulse_ctrl.vhd +-- Author : Gianmarco Girau +-- Company : Global Inkjet Systems +-- Created : 2017-09-06 +-- Last update: 2020-05-15 +-- SVN ID : Git +-- Standard : VHDL'08 +------------------------------------------------------------------------------- +-- Description: +-- Control service logic for the Fire-Controller-Manager +------------------------------------------------------------------------------- +-- altera vhdl_input_version vhdl_2008 + +library ieee; +use ieee.std_logic_1164.all; +use ieee.numeric_std.all; + + +entity fire_pulse_ctrl_8 is + port( + reset_n : in std_logic; + clk : in std_logic; + fpm_config : in std_logic_vector(9 downto 0); + fpm_init : out std_logic; + fpm_init_done : in std_logic; + src_sel : out std_logic_vector(3 downto 0); + uart_regen_bypass : out std_logic; + pof_protocol_version : out std_logic; + enable_rx : out std_logic; + error_rate_thres : out std_logic_vector(7 downto 0); + max_error_flag : in std_logic; + rx_watchdog : in std_logic; + print_start_pof_rx : in std_logic; + print_start_override : out std_logic_vector(1 downto 0); + rx_watchdog_en : out std_logic; + rx_watchdog_clr : out std_logic; + parity_err_cnt : in std_logic_vector(15 downto 0); + skip_pos_cnt : in std_logic_vector(15 downto 0); + pd_cnt : in std_logic_vector(15 downto 0); + mon_point_src : in std_logic_vector(15 downto 0); + mon_points : out std_logic_vector(3 downto 0); + coarse_time : out std_logic_vector(31 downto 0); + fine_time : out std_logic_vector(27 downto 0); + one_pps : out std_logic; + dw_src : out std_logic_vector(3 downto 0); + dw_pulse_width : out std_logic_vector(15 downto 0); + led_status : in std_logic_vector(11 downto 0); + -- Interrupt Senders + ins_fpm_irq_0 : out std_logic; + -- Avalon MM Interface + avs_address : in std_logic_vector(4 downto 0); + avs_write : in std_logic; + avs_writedata : in std_logic_vector(31 downto 0); + avs_read : in std_logic; + avs_readdata : out std_logic_vector(31 downto 0)); +end entity fire_pulse_ctrl_8; + +architecture rtl of fire_pulse_ctrl_8 is + + ----------------------------------------------------------------------------- + -- Constants, Signals + ----------------------------------------------------------------------------- + + constant FINE_TIME_TC : integer := 100000000 - 1; -- clk must be 100MHz to + -- make it right + + signal enable_rx_i : std_logic; + signal fine_time_wrap, time_ld_en : std_logic; + signal rx_watchdog_en_i, rx_watchdog_clr_i : std_logic; + signal uart_regen_bypass_i : std_logic; + signal pof_protocol_version_i : std_logic; + signal fpm_init_start : std_logic; + signal irq, irq_src, irq_src_d : std_logic_vector(0 downto 0); + signal irq_en, irq_mask, irq_val, irq_clr : std_logic_vector(0 downto 0); + signal src_sel_i, dw_src_i : std_logic_vector(3 downto 0); + signal mp_sel0, mp_sel1, mp_sel2, mp_sel3 : std_logic_vector(3 downto 0); + signal error_rate_thres_i : std_logic_vector(7 downto 0); + signal dw_pulse_width_i : std_logic_vector(15 downto 0); + signal fine_time_init, fine_time_i : std_logic_vector(27 downto 0); + signal coarse_time_init, coarse_time_i : std_logic_vector(31 downto 0); + +begin + + pCTRL_REGs : process(reset_n, clk) + begin -- process + if (reset_n = '0') then + fine_time_i <= (others => '0'); + coarse_time_i <= (others => '0'); + elsif (clk = '1' and clk'event) then + if (time_ld_en = '1') then + fine_time_i <= fine_time_init; + elsif (fine_time_wrap = '1') then + fine_time_i <= (others => '0'); + else + fine_time_i <= std_logic_vector(unsigned(fine_time_i) + 1); + end if; + if (time_ld_en = '1') then + coarse_time_i <= coarse_time_init; + elsif (fine_time_wrap = '1') then + coarse_time_i <= std_logic_vector(unsigned(coarse_time_i) + 1); + end if; + one_pps <= fine_time_wrap; + end if; + end process pCTRL_REGs; + + fpm_init <= fpm_init_start; + + fine_time_wrap <= '1' when unsigned(fine_time_i) = FINE_TIME_TC else '0'; + + coarse_time <= coarse_time_i; + fine_time <= fine_time_i; + + dw_src <= dw_src_i; + dw_pulse_width <= dw_pulse_width_i; + + -- MOnitoring Point selection + mon_points(0) <= mon_point_src(to_integer(unsigned(mp_sel0))); + mon_points(1) <= mon_point_src(to_integer(unsigned(mp_sel1))); + mon_points(2) <= mon_point_src(to_integer(unsigned(mp_sel2))); + mon_points(3) <= mon_point_src(to_integer(unsigned(mp_sel3))); + + ----------------------------------------------------------------------------- + -- IRQ generation and management + ----------------------------------------------------------------------------- + + pIRQ : process(reset_n, clk) + begin + if (reset_n = '0') then + ins_fpm_irq_0 <= '0'; + irq <= "0"; + irq_src_d <= "0"; + elsif (clk = '1' and clk'event) then + irq_src_d <= irq_src; + for n in 0 to irq'left loop + if (irq_clr(n) = '1') then + irq(n) <= '0'; + elsif (irq_en(n) = '1' and irq_src(n) = '1' and irq_src_d(n) = '0') then + irq(n) <= '1'; + end if; + end loop; -- n + ins_fpm_irq_0 <= irq_val(0); + end if; + end process pIRQ; + + irq_val <= irq and not irq_mask; + irq_src <= "1" when max_error_flag = '1' or rx_watchdog = '1' else "0"; + + ----------------------------------------------------------------------------- + -- C&S registers + ----------------------------------------------------------------------------- + + fpm_ctrl_csr_regs_i : entity work.fpm_ctrl_8_csr_regs + generic map( + ADDR_DECODE_WIDTH => 5 + ) + port map( + -- Clock and reset + clk => clk, + rst_n => reset_n, + + -- auto-generated + + -- Internal signal ports + fpm_init_start => fpm_init_start, + signal_selection_fire_pulse_sel => src_sel_i(0), + signal_selection_enc_pd_emul_en => src_sel_i(1), + signal_selection_seb_epd_en => src_sel_i(2), + signal_selection_seb_epd_linkout_sel => src_sel_i(3), + signal_selection_print_start_override => print_start_override, + pof_receiver_control_pof_rx_enable => enable_rx_i, + pof_receiver_control_uart_regeneration_bypass => uart_regen_bypass_i, + pof_receiver_control_clear_max => open, + pof_receiver_control_clear_min => open, + pof_receiver_control_uart_rx_div => open, + pof_receiver_control_pof_protocol_version => pof_protocol_version_i, + monitoring_point_selection_mp0 => mp_sel0, + monitoring_point_selection_mp1 => mp_sel1, + monitoring_point_selection_mp2 => mp_sel2, + monitoring_point_selection_mp3 => mp_sel3, + coarse_time_init => coarse_time_init, + fine_time_init_fine_time_init => fine_time_init, + fine_time_init_time_load_en => time_ld_en, + pof_rx_control_w_error_rate_thres => error_rate_thres_i, + pof_rx_control_w_rx_watchdog_en => rx_watchdog_en_i, + pof_rx_control_w_rx_watchdog_clr => rx_watchdog_clr_i, + fpm_interrupt_irq_en => irq_en(0), + fpm_interrupt_irq_clr => irq_clr(0), + fpm_interrupt_irq_mask => irq_mask(0), + drop_watch_config_dw_src => dw_src_i, + drop_watch_config_dw_pulse_width => dw_pulse_width_i, + fpm_config_ch_num => fpm_config(3 downto 0), + fpm_config_seb_epd_logic_present => fpm_config(4), + fpm_config_epd_diagnostic_present => fpm_config(5), + fpm_config_event_logger_present => fpm_config(6), + fpm_config_delay_equalization_enable => fpm_config(7), + fpm_config_tof_comp_enable => fpm_config(8), + fpm_config_pixel_pitch_corr_enable => fpm_config(9), + fpm_init_done => fpm_init_done, + fine_time_status => fine_time_i, + coarse_time_status => coarse_time_i, + pof_rx_status_parity_bit_error_count => parity_err_cnt, + pof_rx_status_skipped_position_error_count => skip_pos_cnt, + pof_rx_control_r_rx_watchdog => rx_watchdog, + pof_rx_control_r_rx_error_flag => max_error_flag, + pof_rx_control_r_print_start_received => print_start_pof_rx, + irq_status => irq_val(0), + pd_cnt => pd_cnt, + seb_epd_led_status_led_pd_g => led_status(0), + seb_epd_led_status_led_pd_y => led_status(1), + seb_epd_led_status_led_pd_r => led_status(2), + seb_epd_led_status_led_enc_p1_g => led_status(3), + seb_epd_led_status_led_enc_p1_y => led_status(4), + seb_epd_led_status_led_enc_p1_r => led_status(5), + seb_epd_led_status_led_enc_p2_g => led_status(6), + seb_epd_led_status_led_enc_p2_y => led_status(7), + seb_epd_led_status_led_enc_p2_r => led_status(8), + seb_epd_led_status_led_pof_in_g => led_status(9), + seb_epd_led_status_led_pof_in_y => led_status(10), + seb_epd_led_status_led_pof_in_r => led_status(11), + + -- end auto-generated + + -- Slave bus port + avs_address => avs_address(4 downto 0), + avs_write => avs_write, + avs_writedata => avs_writedata, + avs_read => avs_read, + avs_readdata => avs_readdata + + ); + + src_sel <= src_sel_i; + enable_rx <= enable_rx_i; + uart_regen_bypass <= uart_regen_bypass_i; + pof_protocol_version <= pof_protocol_version_i; + + error_rate_thres <= error_rate_thres_i; + rx_watchdog_en <= rx_watchdog_en_i; + rx_watchdog_clr <= rx_watchdog_clr_i; + +end architecture rtl; diff --git a/generic_ip/fire_pulse_manager/8/src/fire_pulse_manager_8.vhd b/generic_ip/fire_pulse_manager/8/src/fire_pulse_manager_8.vhd new file mode 100644 index 0000000..3ca2984 --- /dev/null +++ b/generic_ip/fire_pulse_manager/8/src/fire_pulse_manager_8.vhd @@ -0,0 +1,905 @@ +------------------------------------------------------------------------------- +-- Title : fire_pulse_manager +-- Project : HMB/EMB/SMB +------------------------------------------------------------------------------- +-- File : fire_pulse_manager.vhd +-- Author : Gianmarco Girau +-- Company : Global Inkjet Systems +-- Created : 2017-09-06 +-- Last update: 2020-05-19 +-- SVN ID : Git +-- Standard : VHDL'08 +------------------------------------------------------------------------------- +-- Description: +-- Generates fire request from the EMS output data +------------------------------------------------------------------------------- +-- altera vhdl_input_version vhdl_2008 + +library ieee; +use ieee.std_logic_1164.all; +use ieee.numeric_std.all; +use work.common_pkg.all; +use work.fire_pulse_8_pkg.all; + +entity fire_pulse_manager_8 is + generic ( + SEB_EPD_MODE : boolean := false; -- Support SEB-EPD + CH_NUM : integer range 1 to 15 := 4; -- number of Pulse-Generator blocks + PD_QUEUE_SIZE : natural := 512; + ADD_EPD_DIAGS : boolean := false; -- Instantiate Encoder PD Diagnostic block + ADD_EVENT_LOGGER : boolean := false; -- Instantiate Event-Logger block + LOG_FIFO_SIZE : natural range 256 to 4096 := 1024; + PULSE_DELAY_EQUAL_EN : boolean := false; + TOF_COMP_EN : boolean := false; + PIXEL_PITCH_CORR_EN : boolean := false; + DEVICE_FAMILY : string := "Cyclone V"); + port( + reset_n : in std_logic; + clk : in std_logic; -- 100MHz + rx_clk : in std_logic; -- 300MHz (typical) + -- Datapath I/Os + pof_rx : in std_logic; -- asynchronous from another device + pof_tx : out std_logic; + pof_iso_en : out std_logic; + seb_epd_mode_en : out std_logic; + seb_epd_enc_p1 : in std_logic; + seb_epd_enc_p2 : in std_logic; + seb_epd_pd : in std_logic; + fire_pulse : out std_logic_vector(32 * CH_NUM - 1 downto 0); + start_of_image : out std_logic_vector(32 * CH_NUM - 1 downto 0); + stream_busy_a : in std_logic_vector(CH_NUM - 1 downto 0) := (others => '0'); + stream_busy_b : in std_logic_vector(CH_NUM - 1 downto 0) := (others => '0'); + dp_dir_out : out std_logic_vector(CH_NUM - 1 downto 0); + abs_pos_out : out std_logic_vector(31 downto 0); + print_start : out std_logic; + mon_pt : out std_logic_vector(3 downto 0); -- Monitoring Points + -- on header J7 + -- Interrupt Senders + ins_fpm_irq_0 : out std_logic; + ins_fpm_irq_1 : out std_logic; -- @suppress "Unused port: ins_fpm_irq_1 is not used in work.fire_pulse_manager_6(rtl)" + ins_fpm_irq_2 : out std_logic; -- @suppress "Unused port: ins_fpm_irq_2 is not used in work.fire_pulse_manager_6(rtl)" + ins_fpm_irq_3 : out std_logic; -- @suppress "Unused port: ins_fpm_irq_3 is not used in work.fire_pulse_manager_6(rtl)" + -- Avalon MM (Slave) Interface + avs_address : in std_logic_vector(14 downto 0); + avs_write : in std_logic; + avs_writedata : in std_logic_vector(31 downto 0); + avs_read : in std_logic; + avs_readdata : out std_logic_vector(31 downto 0)); +end entity fire_pulse_manager_8; + +architecture rtl of fire_pulse_manager_8 is + + constant POF_UART_BIT_BIV : integer := 6; -- POF-Rx UART sampling clock vs + -- baudrate ratio + + constant BLK_NUM : natural := 6 + CH_NUM; + + signal reset_n_i : std_logic; + -- + signal cs_addr : std_logic_vector(10 downto 0); + signal cs_write_en : std_logic_vector(BLK_NUM - 1 downto 0); + signal cs_write_data : std_logic_vector(31 downto 0); + signal cs_read_en : std_logic_vector(BLK_NUM - 1 downto 0); + signal cs_read_data : std_logic_vector(32 * BLK_NUM - 1 downto 0); + -- + signal cs_ctrl_write_en : std_logic; + signal cs_ctrl_read_en : std_logic; + signal cs_ctrl_read_data : std_logic_vector(31 downto 0); + -- + signal cs_pg_write_en : std_logic_vector(CH_NUM - 1 downto 0); + signal cs_pg_read_en : std_logic_vector(CH_NUM - 1 downto 0); + signal cs_pg_read_data : std_logic_vector(32 * CH_NUM - 1 downto 0); + -- + signal cs_diag_write_en : std_logic; + signal cs_diag_read_en : std_logic; + signal cs_diag_read_data : std_logic_vector(31 downto 0); + -- + signal cs_log_write_en : std_logic; + signal cs_log_read_en : std_logic; + signal cs_log_read_data : std_logic_vector(31 downto 0); + -- + signal cs_ie_write_en : std_logic; + signal cs_ie_read_en : std_logic; + signal cs_ie_read_data : std_logic_vector(31 downto 0); + -- + signal cs_ems_write_en : std_logic; + signal cs_ems_read_en : std_logic; + signal cs_ems_read_data : std_logic_vector(31 downto 0); + -- + signal cs_pof_write_en : std_logic; + signal cs_pof_read_en : std_logic; + signal cs_pof_read_data : std_logic_vector(31 downto 0); + -- + signal enable_rx : std_logic; + signal uart_regen_bypass : std_logic; + signal max_error_flag : std_logic; + signal rx_watchdog : std_logic; + signal rx_watchdog_en : std_logic; + signal rx_watchdog_clr : std_logic; + signal print_start_pof_rx : std_logic; + signal dw_src : std_logic_vector(3 downto 0); + signal error_rate_thres : std_logic_vector(7 downto 0); + signal parity_err_cnt : std_logic_vector(15 downto 0); + signal skip_pos_cnt : std_logic_vector(15 downto 0); + signal mon_point_src : std_logic_vector(15 downto 0); + signal dw_pulse_width : std_logic_vector(15 downto 0); + signal fine_time : std_logic_vector(27 downto 0); + signal coarse_time : std_logic_vector(31 downto 0); + -- + signal init : std_logic; -- strobing this sends init signal over pof_tx. it is also a sort of reset to pd_cnt, simple_enc_vel_detect, pulse_generator, ems, seb_led_gen, smb_diagnostics, dw_pulse + signal remote_init : std_logic; + signal dp_dir : std_logic_vector(CH_NUM - 1 downto 0); + signal set_pos_ie : std_logic; -- set for internal encoder / encoder emulator + signal enc_pulse : std_logic_vector(CH_NUM - 1 downto 0); + signal pd_pulse : std_logic; + signal pd_pulse_ie : std_logic; + signal pd_pulse_pof : std_logic; + signal pd_ems : std_logic; + -- + signal inc_pos : std_logic; + signal inc_pos_pof : std_logic; + signal inc_pos_ie : std_logic; + signal inc_pos_ems : std_logic; + signal dec_pos : std_logic; + signal dec_pos_pof : std_logic; + signal dec_pos_ie : std_logic; + signal dec_pos_ems : std_logic; + signal abs_pos : std_logic_vector(31 downto 0); + signal abs_pos_pof : std_logic_vector(31 downto 0); + signal abs_pos_ems : std_logic_vector(31 downto 0); + signal abs_pos_ie : std_logic_vector(39 downto 0); + -- + signal pd_pulse_mux : std_logic; + signal enc_p1_mux : std_logic; + signal enc_p2_mux : std_logic; + signal enc_p1_ie : std_logic; + signal enc_p2_ie : std_logic; + signal ems_filt_pd : std_logic; + signal ems_filt_p1 : std_logic; + signal ems_filt_p2 : std_logic; + -- + signal pof_tx_regen_0, pof_tx_regen_1 : std_logic; + signal pof_tx_regen : std_logic; + signal pof_tx_data : std_logic; + signal dw_pulse : std_logic; + signal dw_pulse_i : std_logic; + signal rst_dw_pulse : std_logic; + signal set_dw_pulse : std_logic; + signal dw_trigger : std_logic; + signal dw_trigger_d : std_logic; + signal dw_pulse_cnt : std_logic_vector(15 downto 0); + -- + signal pd_cnt : std_logic_vector(15 downto 0); + -- + type fire_pulse_t is array (0 to CH_NUM - 1) of std_logic_vector(31 downto 0); + signal ch_fire_pulse : fire_pulse_t; + signal ch_start_of_image : fire_pulse_t; + signal ch_pd : std_logic_vector(CH_NUM - 1 downto 0); + signal ch_raw_pulse, ch_mask : std_logic_vector(CH_NUM - 1 downto 0); + -- + constant SRC_SEL_SEB_EPD_LINKOUT_SEL : integer := 3; + constant SRC_SEL_SEB_EPD_EN : integer := 2; + constant SRC_SEL_ENC_PD_EMUL_EN : integer := 1; + constant SRC_SEL_FIRE_PULSE_SEL : integer := 0; + signal src_sel : std_logic_vector(3 downto 0); -- seb_epd_linkout_sel, seb_epd_en, enc_pd_emul_en, fire_pulse_sel + -- + signal fire_pulse_ctrl_init : std_logic; -- init signal driven by control register + -- + signal ext_fp_in_sync : std_logic; + signal ext_fp_in : std_logic; + signal ext_fp_in_d : std_logic; + signal ext_fp : std_logic; + -- + type vel_samp_per_vec_t is array (0 to CH_NUM - 1) of std_logic_vector(19 downto 0); + signal vel_meas : std_logic_vector(19 downto 0); + signal vel_sampling_per : vel_samp_per_vec_t; + -- + signal one_pps : std_logic; + signal log_data_src : std_logic_vector(31 downto 0); + -- + signal led_pd_g : std_logic; + signal led_pd_y : std_logic; + signal led_pd_r : std_logic; + signal led_enc_p1_g : std_logic; + signal led_enc_p1_y : std_logic; + signal led_enc_p1_r : std_logic; + signal led_enc_p2_g : std_logic; + signal led_enc_p2_y : std_logic; + signal led_enc_p2_r : std_logic; + signal led_pof_g : std_logic; + signal led_pof_y : std_logic; + signal led_pof_r : std_logic; + signal led_status : std_logic_vector(11 downto 0); + -- + signal fpm_generic_status : std_logic_vector(9 downto 0); + signal pof_protocol_version : std_logic; + signal iPOF_TX_init_done : std_logic; + signal print_start_override : std_logic_vector(1 downto 0); + signal print_start_i : std_logic; + +begin + + ----------------------------------------------------------------------------- + -- Synchronize the input reset (h2f_reset) to the clock (from PLL) + ----------------------------------------------------------------------------- + + iSyncReset : entity work.sync_reset + port map( + async_rstN => reset_n, + clk => clk, + sync_rstN => reset_n_i); + + + ----------------------------------------------------------------------------- + -- C&S Register Interface Splitting + ----------------------------------------------------------------------------- + + iCS_BUS_ITF : entity work.cs_bus_ift_no_wait + generic map( + BLK_NUM => BLK_NUM) + port map( + rstN => reset_n_i, + clk => clk, + avs_address => avs_address(14 downto 0), + avs_write => avs_write, + avs_writedata => avs_writedata, + avs_read => avs_read, + avs_readdata => avs_readdata, + cs_addr => cs_addr, + cs_we => cs_write_en, + cs_wr_data => cs_write_data, + cs_re => cs_read_en, + cs_rd_data => cs_read_data); + + cs_ctrl_write_en <= cs_write_en(FP_CTRL_ID); + cs_diag_write_en <= cs_write_en(DIAG_BLK_ID); + cs_log_write_en <= cs_write_en(LOG_BLK_ID); + cs_ie_write_en <= cs_write_en(INT_ENC_ID); + cs_ems_write_en <= cs_write_en(EMS_BLK_ID); + cs_pof_write_en <= cs_write_en(POF_BLK_ID); + cs_pg_write_en_g : for i in 1 to CH_NUM generate + cs_pg_write_en(i - 1) <= cs_write_en(PG_CH_ID + i - 1); + end generate; + + cs_ctrl_read_en <= cs_read_en(FP_CTRL_ID); + cs_diag_read_en <= cs_read_en(DIAG_BLK_ID); + cs_log_read_en <= cs_read_en(LOG_BLK_ID); + cs_ie_read_en <= cs_read_en(INT_ENC_ID); + cs_ems_read_en <= cs_read_en(EMS_BLK_ID); + cs_pof_read_en <= cs_read_en(POF_BLK_ID); + cs_pg_read_en_g : for i in 1 to CH_NUM generate + cs_pg_read_en(i - 1) <= cs_read_en(PG_CH_ID + i - 1); + end generate; + + cs_read_data(31 + 32 * FP_CTRL_ID downto 32 * FP_CTRL_ID) <= cs_ctrl_read_data; + cs_read_data(31 + 32 * DIAG_BLK_ID downto 32 * DIAG_BLK_ID) <= cs_diag_read_data; + cs_read_data(31 + 32 * LOG_BLK_ID downto 32 * LOG_BLK_ID) <= cs_log_read_data; + cs_read_data(31 + 32 * INT_ENC_ID downto 32 * INT_ENC_ID) <= cs_ie_read_data; + cs_read_data(31 + 32 * EMS_BLK_ID downto 32 * EMS_BLK_ID) <= cs_ems_read_data; + cs_read_data(31 + 32 * POF_BLK_ID downto 32 * POF_BLK_ID) <= cs_pof_read_data; + cs_read_data_pg_g : for i in 1 to CH_NUM generate + cs_read_data(31 + 32 * (PG_CH_ID + i - 1) downto 32 * (PG_CH_ID + i - 1)) <= cs_pg_read_data(31 + 32 * (i - 1) downto 32 * (i - 1)); + end generate; + + ----------------------------------------------------------------------------- + -- Fire-Pulse-Manager Controller + ----------------------------------------------------------------------------- + + iCTRL : entity work.fire_pulse_ctrl_8 + port map( + reset_n => reset_n_i, + clk => clk, + fpm_config => fpm_generic_status, + fpm_init => fire_pulse_ctrl_init, + fpm_init_done => iPOF_TX_init_done, + src_sel => src_sel, + uart_regen_bypass => uart_regen_bypass, + pof_protocol_version => pof_protocol_version, + enable_rx => enable_rx, + error_rate_thres => error_rate_thres, + max_error_flag => max_error_flag, + rx_watchdog => rx_watchdog, + print_start_pof_rx => print_start_pof_rx, + print_start_override => print_start_override, + rx_watchdog_en => rx_watchdog_en, + rx_watchdog_clr => rx_watchdog_clr, + parity_err_cnt => parity_err_cnt, + skip_pos_cnt => skip_pos_cnt, + pd_cnt => pd_cnt, + mon_point_src => mon_point_src, + mon_points => mon_pt, + coarse_time => coarse_time, + fine_time => fine_time, + one_pps => one_pps, + dw_src => dw_src, + dw_pulse_width => dw_pulse_width, + led_status => led_status, + ins_fpm_irq_0 => ins_fpm_irq_0, + avs_address => cs_addr(4 downto 0), + avs_write => cs_ctrl_write_en, + avs_writedata => cs_write_data, + avs_read => cs_ctrl_read_en, + avs_readdata => cs_ctrl_read_data); + + fpm_generic_status(3 downto 0) <= std_logic_vector(to_unsigned(CH_NUM, 4)); + fpm_generic_status(4) <= '1' when SEB_EPD_MODE = true else '0'; + fpm_generic_status(5) <= '1' when ADD_EPD_DIAGS = true else '0'; + fpm_generic_status(6) <= '1' when ADD_EVENT_LOGGER = true else '0'; + fpm_generic_status(7) <= '1' when PULSE_DELAY_EQUAL_EN = true else '0'; + fpm_generic_status(8) <= '1' when TOF_COMP_EN = true else '0'; + fpm_generic_status(9) <= '1' when PIXEL_PITCH_CORR_EN = true else '0'; + + + ----------------------------------------------------------------------------- + -- I/Os selection + ----------------------------------------------------------------------------- + + pENC_PD_SRC_SEL : process(clk) + begin + if (clk = '1' and clk'event) then + -- Abs-Pos and PD source selection + if (src_sel(SRC_SEL_SEB_EPD_EN) = '1') then + -- Use SEB-EPD inputs + pd_pulse <= pd_ems; + abs_pos <= abs_pos_ems; + inc_pos <= inc_pos_ems; + dec_pos <= dec_pos_ems; + else + if (src_sel(SRC_SEL_ENC_PD_EMUL_EN) = '0') then + pd_pulse <= pd_pulse_pof; + abs_pos <= abs_pos_pof; + inc_pos <= inc_pos_pof; + dec_pos <= dec_pos_pof; + else + pd_pulse <= pd_pulse_ie; + abs_pos <= abs_pos_ie(31 downto 0); + inc_pos <= inc_pos_ie; + dec_pos <= dec_pos_ie; + end if; + end if; + end if; + end process pENC_PD_SRC_SEL; + + gPOF_TX_OUT : if SEB_EPD_MODE = true generate + + pof_tx <= dw_pulse when src_sel(SRC_SEL_SEB_EPD_LINKOUT_SEL) = '1' else + pof_tx_regen when src_sel(SRC_SEL_SEB_EPD_EN) = '0' else + pof_tx_data; + + pBUF_SEB_EPD_MODE : process(clk) + begin + if (clk = '1' and clk'event) then + seb_epd_mode_en <= src_sel(SRC_SEL_SEB_EPD_EN); + end if; + end process pBUF_SEB_EPD_MODE; + + else generate + + pof_tx <= pof_tx_regen; + + seb_epd_mode_en <= '0'; + + end generate gPOF_TX_OUT; + + pBUF_OUT : process(clk) + begin + if (clk = '1' and clk'event) then + abs_pos_out <= abs_pos; + dp_dir_out <= dp_dir; + for i in 0 to CH_NUM - 1 loop + if (src_sel(SRC_SEL_FIRE_PULSE_SEL) = '1') then + fire_pulse(i * 32 + 31 downto i * 32) <= ch_fire_pulse(i); + start_of_image(i * 32 + 31 downto i * 32) <= ch_start_of_image(i); + else + fire_pulse(i * 32 + 31 downto i * 32) <= (others => ext_fp); + start_of_image(i * 32 + 31 downto i * 32) <= (others => '0'); + end if; + end loop; -- i + if print_start_override(1) = '1' then -- force output value and control to pof_tx (if present) + print_start_i <= print_start_override(0); + elsif pof_protocol_version = '0' then -- for protocol 0, start is always enabled + print_start_i <= '1'; + else -- use the received value + print_start_i <= print_start_pof_rx; + end if; + + end if; + end process pBUF_OUT; + print_start <= print_start_i; + + pINIT_GEN : process(clk) + begin + if (clk = '1' and clk'Event) then + init <= '0'; + if fire_pulse_ctrl_init = '1' then -- signal from control registers + init <= '1'; + elsif src_sel(SRC_SEL_ENC_PD_EMUL_EN) = '1' then -- setting the internal encoder position also re-initialises + init <= set_pos_ie; -- fpm_init_done should be polled by ESW before any further actions to ensure init is complete + elsif src_sel(SRC_SEL_SEB_EPD_EN) = '0' and remote_init = '1' then + -- source is not SEB-EPD (i.e. it's the SEB-PDW RX link) and we received an init signal over the POF RX link (it's a strobe) + init <= '1'; + elsif src_sel(SRC_SEL_SEB_EPD_EN) = '0' and enable_rx = '0' then + -- source is not enc_pd_emul and is not SEB-EPD (i.e. it's the SEB-PDW RX link) but the RX link has been disabled + -- FIXME - will this condition hold several systems in reset, but not begin the pof_tx init process? + init <= '1'; + end if; + end if; + end process pINIT_GEN; + + mon_point_src(0) <= init; + mon_point_src(1) <= dp_dir(0); + mon_point_src(2) <= pd_pulse; + mon_point_src(3) <= enc_pulse(0); + mon_point_src(4) <= ch_pd(0); + mon_point_src(5) <= ch_fire_pulse(0)(0); + mon_point_src(6) <= ch_raw_pulse(0); + mon_point_src(7) <= ch_mask(0); + mon_point_src(8) <= pof_rx; + mon_point_src(9) <= ch_fire_pulse(0)(0); + mon_point_src(10) <= ch_start_of_image(0)(0); + mon_point_src(11) <= inc_pos; + mon_point_src(12) <= dec_pos; + mon_point_src(13) <= print_start_pof_rx; + -- + mon_point_src(15 downto 14) <= (others => '0'); + + pof_iso_en <= enable_rx; + + ----------------------------------------------------------------------------- + -- PD Counter + ----------------------------------------------------------------------------- + + pPD_CNT : process(clk) + begin + if (clk = '1' and clk'event) then + if (init = '1') then + pd_cnt <= (others => '0'); + elsif (pd_pulse = '1') then + pd_cnt <= std_logic_vector(unsigned(pd_cnt) + 1); + end if; + end if; + end process pPD_CNT; + + ----------------------------------------------------------------------------- + -- Encoder Speed Detection + ----------------------------------------------------------------------------- + + gENC_VEL : if TOF_COMP_EN = true generate + + -- Used for Time-of-Flight Compensation + iVEL : entity work.simple_enc_vel_detect_8 + port map ( + clk => clk, + init => init, + step_pos => inc_pos, + step_neg => dec_pos, + sampling_period => vel_sampling_per(0), + vel_meas => vel_meas); + + else generate + + vel_meas <= (others => '0'); + + end generate gENC_VEL; + + ----------------------------------------------------------------------------- + -- Pulse Generator + ----------------------------------------------------------------------------- + + pulse_generator_g : for i in 0 to CH_NUM - 1 generate + iCH_PG : entity work.pulse_generator_6 + generic map( + PD_QUEUE_SIZE => PD_QUEUE_SIZE, + PULSE_DELAY_EQUAL_EN => PULSE_DELAY_EQUAL_EN, + SPITTING_EN => false, + BIDIR_CH_OFFSET_EN => false, + DIAG_COUNTERS => true, + TOF_COMP_EN => TOF_COMP_EN, + PIXEL_PITCH_CORR_EN => PIXEL_PITCH_CORR_EN, + DEVICE_FAMILY => DEVICE_FAMILY + ) + port map( + clk => clk, + reset_n => reset_n_i, + init => init, + pd_in => pd_pulse, + abs_position => abs_pos, + enc_vel => vel_meas, + enc_speed_meas_w => vel_sampling_per(i), + dp_dir => dp_dir(i), + fire_req_vec => ch_fire_pulse(i), + start_of_image_vec => ch_start_of_image(i), + stream_busy_a => stream_busy_a(i), + stream_busy_b => stream_busy_b(i), + filtered_pd => open, + ch_pd => ch_pd(i), + ch_mask => ch_mask(i), + raw_fire_req => ch_raw_pulse(i), + enc_pulse => enc_pulse(i), + avs_address => cs_addr(10 downto 0), + avs_write => cs_pg_write_en(i), + avs_writedata => cs_write_data, + avs_read => cs_pg_read_en(i), + avs_readdata => cs_pg_read_data(31 + 32*i downto 32*i)); + end generate; + + ----------------------------------------------------------------------------- + -- POF Rx Interface + ----------------------------------------------------------------------------- + + -- UART signal regeneration for protocol ver 0 + iUART_REGEN_protver0 : entity work.pof_uart_regen_3 + generic map( + GEN_BIT_DIV => POF_UART_BIT_BIV, + data_width => 8) + port map( + reset_n => reset_n, + clk => rx_clk, + enable => enable_rx, -- from slower clk domain - crossing handled within this block + bypass_en => uart_regen_bypass, -- from slower clk domain + uart_rx => pof_rx, -- from another device + uart_tx => pof_tx_regen_0); + + -- UART signal regeneration for protocol ver 1 + iUART_REGEN_protver1 : entity work.pof_uart_regen_3 + generic map( + GEN_BIT_DIV => POF_UART_BIT_BIV, + data_width => 9) + port map( + reset_n => reset_n, + clk => rx_clk, + enable => enable_rx, + bypass_en => uart_regen_bypass, + uart_rx => pof_rx, + uart_tx => pof_tx_regen_1); + + -- select which protocol to retransmit + pof_tx_regen <= pof_tx_regen_0 when pof_protocol_version = '0' else pof_tx_regen_1; + + iPOF_RX : entity work.pof_rx_3 + generic map( + GEN_BIT_DIV => POF_UART_BIT_BIV) + port map( + reset_n => reset_n_i, + clk => clk, + init => '0', + rx_clk => rx_clk, + rx_data => pof_rx, + init_out => remote_init, + pd_out => pd_pulse_pof, + print_start => print_start_pof_rx, + inc_pos => inc_pos_pof, + dec_pos => dec_pos_pof, + abs_pos => abs_pos_pof, + pof_protocol_version => pof_protocol_version, + enable => enable_rx, + error_rate_thres => error_rate_thres, + one_pps => one_pps, + max_error_flag => max_error_flag, + rx_watchdog => rx_watchdog, + rx_watchdog_en => rx_watchdog_en, + rx_watchdog_clr => rx_watchdog_clr, + parity_err_cnt => parity_err_cnt, + skip_pos_cnt => skip_pos_cnt); + + + ----------------------------------------------------------------------------- + -- EMS + ----------------------------------------------------------------------------- + + gEMS : if SEB_EPD_MODE = true generate + + iEMS : entity work.ems_1 + generic map( + ADD_ENC_ZP_LOGIC => false, + ADD_MULT_DEBUG_REG => false, + GEN_PRINT_START => false) + port map( + clk => clk, + reset_n => reset_n_i, + init => init, + avs_address => cs_addr(3 downto 0), + avs_write => cs_ems_write_en, + avs_writedata => cs_write_data, + avs_read => cs_ems_read_en, + avs_readdata => cs_ems_read_data, + rs422_pd => pd_pulse_mux, + rs422_p1 => enc_p1_mux, + rs422_p2 => enc_p2_mux, + rs422_zp => '0', + ttl_pd => '0', + ttl_pd_npn => '0', + ttl_p1 => '0', + ttl_p2 => '0', + ttl_zp => '0', + abs_position => abs_pos_ems, + pd_out => pd_ems, + print_start => open, + set_pos => open, + inc_pos => inc_pos_ems, + dec_pos => dec_pos_ems, + filt_p1 => ems_filt_p1, + filt_p2 => ems_filt_p2, + filt_zp => open, + filt_pd => ems_filt_pd); + + pd_pulse_mux <= seb_epd_pd when src_sel(SRC_SEL_ENC_PD_EMUL_EN) = '0' else pd_pulse_ie; + enc_p1_mux <= seb_epd_enc_p1 when src_sel(SRC_SEL_ENC_PD_EMUL_EN) = '0' else enc_p1_ie; + enc_p2_mux <= seb_epd_enc_p2 when src_sel(SRC_SEL_ENC_PD_EMUL_EN) = '0' else enc_p2_ie; + + else generate + + cs_ems_read_data <= X"DEAD_BEEF"; + + abs_pos_ems <= (others => '0'); + pd_ems <= '0'; + inc_pos_ems <= '0'; + dec_pos_ems <= '0'; + + end generate gEMS; + + ----------------------------------------------------------------------------- + -- POF-Tx + ----------------------------------------------------------------------------- + + gPOF_TX : if SEB_EPD_MODE = true generate + -- Default POF-Protocol + iPOF_TX : entity work.pof_tx_3 + generic map( + DEVICE_FAMILY => DEVICE_FAMILY + ) + port map( + reset_n => reset_n_i, + clk => clk, + init => init, + init_done => iPOF_TX_init_done, + pd_in => pd_ems, + print_start => print_start_i, -- note for the 0th in chain, this must be set using override in fire pulse ctrl + pof_protocol_version => pof_protocol_version, + inc_pos => inc_pos_ems, + dec_pos => dec_pos_ems, + abs_position => abs_pos_ems, + tx_data => pof_tx_data, + avs_address => cs_addr(2 downto 0), + avs_write => cs_pof_write_en, + avs_writedata => cs_write_data, + avs_read => cs_pof_read_en, + avs_readdata => cs_pof_read_data); + + else generate + + cs_pof_read_data <= X"DEAD_BEEF"; + + pof_tx_data <= '0'; + + iPOF_TX_init_done <= '1'; -- always assume it's complete! + + end generate gPOF_TX; + + ----------------------------------------------------------------------------- + -- SEB-EPD LEDs + ----------------------------------------------------------------------------- + + gSEB_EPD_LEDs : if SEB_EPD_MODE = true generate + iLED_GEN : entity work.seb_epd_led_gen_8 + port map( + reset_n => reset_n, + clk => clk, + init => init, + pd => ems_filt_pd, + enc_p1 => ems_filt_p1, + enc_p2 => ems_filt_p2, + pof => pof_rx, + all_ok => '1', + led_pd_g => led_pd_g, + led_pd_y => led_pd_y, + led_pd_r => led_pd_r, + led_enc_p1_g => led_enc_p1_g, + led_enc_p1_y => led_enc_p1_y, + led_enc_p1_r => led_enc_p1_r, + led_enc_p2_g => led_enc_p2_g, + led_enc_p2_y => led_enc_p2_y, + led_enc_p2_r => led_enc_p2_r, + led_pof_g => led_pof_g, + led_pof_y => led_pof_y, + led_pof_r => led_pof_r); + + led_status(2 downto 0) <= led_pd_r & led_pd_y & led_pd_g; + led_status(5 downto 3) <= led_enc_p1_r & led_enc_p1_y & led_enc_p1_g; + led_status(8 downto 6) <= led_enc_p2_r & led_enc_p2_y & led_enc_p2_g; + led_status(11 downto 9) <= led_pof_r & led_pof_y & led_pof_g; + + else generate + + led_status <= (others => '0'); + + end generate gSEB_EPD_LEDs; + + ----------------------------------------------------------------------------- + -- Diagnostic block + ----------------------------------------------------------------------------- + + gDIAG : if ADD_EPD_DIAGS = false generate + + cs_diag_read_data <= X"DEAD_BEEF"; + + ins_fpm_irq_1 <= '0'; + ins_fpm_irq_2 <= '0'; + ins_fpm_irq_3 <= '0'; + + elsif ADD_EPD_DIAGS = true generate + + iDiagnostic : entity work.epd_diagnostics_8 + generic map ( + DEVICE_FAMILY => DEVICE_FAMILY + ) + port map( + clk => clk, + reset_n => reset_n_i, + ext_diag_rst => init, + rs422_phase0 => seb_epd_enc_p1, + rs422_phase1 => seb_epd_enc_p2, + rs422_zero_ph => '0', + rs422_prod_det => seb_epd_pd, + ttl_phase0 => '0', + ttl_phase1 => '0', + ttl_zero_ph => '0', + ttl_prod_det => '0', + ttl_prod_det_npn => '0', + filt_phase0 => ems_filt_p1, + filt_phase1 => ems_filt_p2, + filt_zero_ph => '0', + filt_prod_det => pd_pulse, + enc_out => enc_pulse(0), + pd_out => ch_pd(0), + pos_step => inc_pos, + neg_step => dec_pos, + drop_watch => '0', + fire_req => ch_fire_pulse(0)(0), + fine_time => fine_time, + coarse_time => coarse_time, + abs_position => open, + ins_diag_irq_0 => ins_fpm_irq_1, + ins_diag_irq_1 => ins_fpm_irq_2, + ins_diag_irq_2 => ins_fpm_irq_3, + avs_address => cs_addr(5 downto 0), + avs_write => cs_diag_write_en, + avs_writedata => cs_write_data, + avs_read => cs_diag_read_en, + avs_readdatavalid => open, + avs_readdata => cs_diag_read_data); + + end generate gDIAG; + + ----------------------------------------------------------------------------- + -- Event Logger + ----------------------------------------------------------------------------- + + gEL : if ADD_EVENT_LOGGER = false generate + + cs_log_read_data <= X"DEAD_BEEF"; + + elsif ADD_EVENT_LOGGER = true generate + + event_logger_0_1 : entity work.event_logger_2 + generic map( + FIFO_SIZE => LOG_FIFO_SIZE, + DEVICE_FAMILY => DEVICE_FAMILY) + port map( + rstN => reset_n_i, + clk => clk, + data_src => log_data_src, + fine_time => fine_time, + abs_position => abs_pos, + ins_irq => open, + avs_address => cs_addr(3 downto 0), + avs_write => cs_log_write_en, + avs_writedata => cs_write_data, + avs_read => cs_log_read_en, + avs_readdata => cs_log_read_data); + + log_data_src(0) <= init; + log_data_src(1) <= dp_dir(0); + log_data_src(2) <= pd_pulse; + log_data_src(3) <= enc_pulse(0); + log_data_src(4) <= ch_pd(0); + log_data_src(5) <= ch_fire_pulse(0)(0); + log_data_src(6) <= ch_raw_pulse(0); + log_data_src(7) <= ch_mask(0); + log_data_src(8) <= pof_rx; + log_data_src(9) <= ch_fire_pulse(0)(0); + log_data_src(10) <= ch_start_of_image(0)(0); + log_data_src(11) <= inc_pos; + log_data_src(12) <= dec_pos; + log_data_src(13) <= print_start_pof_rx; + -- + log_data_src(31 downto 14) <= (others => '0'); + + end generate gEL; + + ----------------------------------------------------------------------------- + -- Ext fire pulse detection + ----------------------------------------------------------------------------- + + -- just filter all the pulses with a width less than 200 ns + pEXT_PULSE_DETECT : process(clk) + variable pulse_width_cnt : std_logic_vector(4 downto 0); + variable pulse_cnt_en : std_logic := '0'; + begin + if (clk = '1' and clk'event) then + ext_fp_in_sync <= pof_rx; + ext_fp_in <= ext_fp_in_sync; + ext_fp <= '0'; + ext_fp_in_d <= ext_fp_in; + if (ext_fp_in = '1' and ext_fp_in_d = '0') then + pulse_cnt_en := '1'; + pulse_width_cnt := (others => '0'); + elsif (pulse_cnt_en = '1' and ext_fp_in_d = '1') then + if (unsigned(pulse_width_cnt) = 19) then + pulse_cnt_en := '0'; + ext_fp <= '1'; + else + pulse_width_cnt := std_logic_vector(unsigned(pulse_width_cnt) + 1); + end if; + end if; + end if; + end process pEXT_PULSE_DETECT; + + ----------------------------------------------------------------------------- + -- Drop-Watch Pulse generation + ----------------------------------------------------------------------------- + + pGEN_DW : process(clk) + begin + if (clk = '1' and clk'event) then + dw_trigger_d <= dw_trigger; + if (rst_dw_pulse = '1') then + dw_pulse_i <= '0'; + elsif (set_dw_pulse = '1') then + dw_pulse_i <= '1'; + end if; + if (rst_dw_pulse = '1') then + dw_pulse_cnt <= (0 => '1', others => '0'); + elsif (dw_pulse_i = '1') then + dw_pulse_cnt <= std_logic_vector(unsigned(dw_pulse_cnt) + 1); + end if; + end if; + end process pGEN_DW; + + dw_trigger <= ch_fire_pulse(to_integer(unsigned(dw_src(log2(CH_NUM) - 1 downto 0))))(0); + + rst_dw_pulse <= '1' when init = '1' or unsigned(dw_pulse_cnt) = unsigned(dw_pulse_width) else '0'; + set_dw_pulse <= dw_trigger and not dw_trigger_d; + + dw_pulse <= dw_pulse_i; + + ----------------------------------------------------------------------------- + -- Internal encoder generator + ----------------------------------------------------------------------------- + + iEMUL : entity work.enc_pd_emul_3 + generic map( + DEVICE_FAMILY => DEVICE_FAMILY, + SEQ_ENABLE => false) + port map( + clk => clk, + reset_n => reset_n_i, + ttl_pd => open, + ttl_enc_p1 => open, + ttl_enc_p2 => open, + ttl_enc_zp => open, + rs422_pd => pd_pulse_ie, + rs422_enc_p1 => enc_p1_ie, + rs422_enc_p2 => enc_p2_ie, + rs422_enc_zp => open, + abs_pos_out => abs_pos_ie, + set_pos_out => set_pos_ie, + inc_pos_out => inc_pos_ie, + dec_pos_out => dec_pos_ie, + avs_address => cs_addr(9 downto 0), + avs_write => cs_ie_write_en, + avs_writedata => cs_write_data, + avs_read => cs_ie_read_en, + avs_readdata => cs_ie_read_data); + +end architecture rtl; diff --git a/generic_ip/fire_pulse_manager/8/src/seb_epd_led_gen_8.vhd b/generic_ip/fire_pulse_manager/8/src/seb_epd_led_gen_8.vhd new file mode 100644 index 0000000..7a86848 --- /dev/null +++ b/generic_ip/fire_pulse_manager/8/src/seb_epd_led_gen_8.vhd @@ -0,0 +1,307 @@ +------------------------------------------------------------------------------- +-- Title : seb_epd_led_gen_8 +-- Project : SMB +------------------------------------------------------------------------------- +-- File : seb_epd_led_gen_8.vhd +-- Author : Gianmarco Girau +-- Company : Global Inkjet Systems +-- Created : 2018-08-06 +-- Last update: 2020-04-16 +-- SVN ID : Git +-- Standard : VHDL'08 +------------------------------------------------------------------------------- +-- Description: +-- Generate signals for driving the SMB LEDs. +-- Note: those signals can still be overwritten by software through the +-- SMB-Ctrl block. +------------------------------------------------------------------------------- + +library ieee; +use ieee.std_logic_1164.all; +use ieee.numeric_std.all; + +entity seb_epd_led_gen_8 is + generic( + MAX_PERIOD_MS : natural := 1000; + GREEN_PERIOD_MS : natural := 200); + port( + reset_n : in std_logic; + clk : in std_logic; + -- config + init : in std_logic; + -- input status signals + pd : in std_logic; + enc_p1 : in std_logic; + enc_p2 : in std_logic; + pof : in std_logic; -- async + all_ok : in std_logic; + -- LEDs outputs values + led_pd_g : out std_logic; + led_pd_y : out std_logic; + led_pd_r : out std_logic; + led_enc_p1_g : out std_logic; + led_enc_p1_y : out std_logic; + led_enc_p1_r : out std_logic; + led_enc_p2_g : out std_logic; + led_enc_p2_y : out std_logic; + led_enc_p2_r : out std_logic; + led_pof_g : out std_logic; + led_pof_y : out std_logic; + led_pof_r : out std_logic); +end entity seb_epd_led_gen_8; + +architecture rtl of seb_epd_led_gen_8 is + + constant END_GREEN_PERIOD_MS : natural := MAX_PERIOD_MS - GREEN_PERIOD_MS; + + signal pd_d, enc_p1_d, enc_p2_d, one_ms_pulse : std_logic; + signal pd_cnt_zero_flag, rst_pd_green, pd_red, pd_green : std_logic; + signal p1_event, p2_event, p1_cnt_zero_flag : std_logic; + signal p2_cnt_zero_flag, pd_event, rst_pof_green : std_logic; + signal rst_p1_green, rst_p2_green, p1_red, p2_red : std_logic; + signal p1_green, p2_green, pof_green, pof_d : std_logic; + signal pof_event, pof_cnt_zero_flag, pof_active : std_logic; + signal all_ok_d, alert_cnt_zero_flag : std_logic; + signal pd_active, p1_active, p2_active : std_logic; + -- + signal alert_led : std_logic_vector(3 downto 0); + signal pd_cnt, pof_cnt : std_logic_vector(9 downto 0); + signal p1_cnt, p2_cnt, alert_cnt : std_logic_vector(9 downto 0); + signal one_ms_cnt : std_logic_vector(16 downto 0); + signal pof_i : std_logic; + +begin + + pGEN_1MS_PULSE : process(reset_n, clk) + begin + if (reset_n = '0') then + one_ms_pulse <= '0'; + one_ms_cnt <= (others => '0'); + elsif (clk = '1' and clk'event) then + if (unsigned(one_ms_cnt) = 100000 - 1) then + one_ms_pulse <= '1'; + one_ms_cnt <= (others => '0'); + else + one_ms_pulse <= '0'; + one_ms_cnt <= std_logic_vector(unsigned(one_ms_cnt) + 1); + end if; + end if; + end process pGEN_1MS_PULSE; + + ----------------------------------------------------------------------------- + -- PD LEDs + ----------------------------------------------------------------------------- + + pPD_LEDs : process(reset_n, clk) is + begin -- process + if (reset_n = '0') then + pd_d <= '0'; + pd_event <= '0'; + pd_cnt <= (others => '0'); + pd_green <= '0'; + led_pd_y <= '0'; + led_pd_g <= '0'; + pd_active <= '0'; + elsif (clk = '1' and clk'event) then + pd_d <= pd; + pd_event <= pd xor pd_d; + if (init = '1') then + pd_cnt <= (others => '0'); + elsif (pd_event = '1') then + pd_cnt <= std_logic_vector(to_unsigned(MAX_PERIOD_MS, pd_cnt'length)); + elsif (pd_cnt_zero_flag = '0' and one_ms_pulse = '1') then + pd_cnt <= std_logic_vector(unsigned(pd_cnt) - 1); + end if; + if (pd_event = '1') then + pd_green <= '1'; + elsif (rst_pd_green = '1' or init = '1') then + pd_green <= '0'; + end if; + led_pd_r <= all_ok and pd_red; + led_pd_y <= (all_ok and pd_cnt_zero_flag and pd_active) or alert_led(0); + led_pd_g <= all_ok and pd_green; + if (pd_event = '1') then + pd_active <= '1'; + end if; + end if; + end process pPD_LEDs; + + pd_cnt_zero_flag <= '1' when unsigned(pd_cnt) = 0 else '0'; + + rst_pd_green <= '1' when one_ms_pulse = '1' and unsigned(pd_cnt) = END_GREEN_PERIOD_MS else '0'; + + -- PD red LED is never activated because there is only one PD source + pd_red <= '0'; + + ----------------------------------------------------------------------------- + -- Encoder LEDs + ----------------------------------------------------------------------------- + + pENC_LEDs : process(reset_n, clk) + begin + if (reset_n = '0') then + p1_cnt <= (others => '0'); + p2_cnt <= (others => '0'); + p1_red <= '0'; + p1_green <= '0'; + p2_red <= '0'; + p2_green <= '0'; + p1_active <= '0'; + p2_active <= '0'; + elsif (clk = '1' and clk'event) then + if (init = '1') then + p1_cnt <= (others => '0'); + elsif (p1_event = '1' and p1_red = '0') then + p1_cnt <= std_logic_vector(to_unsigned(MAX_PERIOD_MS - 1, p1_cnt'length)); + elsif (p1_cnt_zero_flag = '0' and one_ms_pulse = '1') then + p1_cnt <= std_logic_vector(unsigned(p1_cnt) - 1); + end if; + if (init = '1') then + p2_cnt <= (others => '0'); + elsif (p2_event = '1' and p2_red = '0') then + p2_cnt <= std_logic_vector(to_unsigned(MAX_PERIOD_MS - 1, p2_cnt'length)); + elsif (p2_cnt_zero_flag = '0' and one_ms_pulse = '1') then + p2_cnt <= std_logic_vector(unsigned(p2_cnt) - 1); + end if; + if (init = '1' or (p1_cnt_zero_flag = '1' and p1_event = '0')) then + p1_red <= '0'; + elsif (p1_event = '1' and p2_event = '1') then + p1_red <= '1'; + end if; + if (init = '1' or (p2_cnt_zero_flag = '1' and p2_event = '0')) then + p2_red <= '0'; + elsif (p2_event = '1' and p1_event = '1') then + p2_red <= '1'; + end if; + if (p1_red = '1' or rst_p1_green = '1' or init = '1') then + p1_green <= '0'; + elsif (p1_event = '1') then + p1_green <= '1'; + end if; + if (p2_red = '1' or rst_p2_green = '1' or init = '1') then + p2_green <= '0'; + elsif (p2_event = '1') then + p2_green <= '1'; + end if; + if (p1_event = '1') then + p1_active <= '1'; + end if; + if (p2_event = '1') then + p2_active <= '1'; + end if; + end if; + end process pENC_LEDs; + + pENC_LEDs_NR : process(clk) + begin + if (clk = '1' and clk'event) then + enc_p1_d <= enc_p1; + enc_p2_d <= enc_p2; + p1_event <= enc_p1 xor enc_p1_d; + p2_event <= enc_p2 xor enc_p2_d; + led_enc_p1_r <= all_ok and p1_red; + led_enc_p1_y <= (all_ok and p1_cnt_zero_flag and not p1_red and p1_active) or alert_led(1); + led_enc_p1_g <= all_ok and p1_green and not p1_red; + led_enc_p2_r <= all_ok and p2_red; + led_enc_p2_y <= (all_ok and p2_cnt_zero_flag and not p2_red and p2_active) or alert_led(2); + led_enc_p2_g <= all_ok and p2_green and not p2_red; + end if; + end process pENC_LEDs_NR; + + p1_cnt_zero_flag <= '1' when unsigned(p1_cnt) = 0 else '0'; + p2_cnt_zero_flag <= '1' when unsigned(p2_cnt) = 0 else '0'; + + rst_p1_green <= '1' when unsigned(p1_cnt) = END_GREEN_PERIOD_MS - 1 and one_ms_pulse = '1' else '0'; + rst_p2_green <= '1' when unsigned(p2_cnt) = END_GREEN_PERIOD_MS - 1 and one_ms_pulse = '1' else '0'; + + ----------------------------------------------------------------------------- + -- POF LEDs + ----------------------------------------------------------------------------- + iSYNC_IN_UARTRX : entity work.sync_wire + generic map( + rst_val => '0', + sync_stages => 3) + port map( + rstN => reset_n, + clk => clk, + async_in => pof, + sync_out => pof_i); + + pPOF_LED : process(reset_n, clk) + begin + if (reset_n = '0') then + pof_cnt <= (others => '0'); + pof_d <= '0'; + pof_green <= '0'; + led_pof_g <= '0'; + led_pof_y <= '0'; + pof_event <= '0'; + pof_active <= '0'; + elsif (clk = '1' and clk'event) then + pof_d <= pof_i; + pof_event <= pof_i and not pof_d; + if (init = '1') then + pof_cnt <= (others => '0'); + elsif (pof_event = '1') then + pof_cnt <= std_logic_vector(to_unsigned(MAX_PERIOD_MS, pof_cnt'length)); + elsif (pof_cnt_zero_flag = '0' and one_ms_pulse = '1') then + pof_cnt <= std_logic_vector(unsigned(pof_cnt) - 1); + end if; + if (init = '1' or (rst_pof_green = '1' and pof_event = '0')) then + pof_green <= '0'; + elsif (pof_event = '1') then + pof_green <= '1'; + end if; + led_pof_g <= all_ok and pof_green; + led_pof_y <= (all_ok and pof_cnt_zero_flag and pof_active) or alert_led(3); + if (pof_event = '1') then + pof_active <= '1'; + end if; + end if; + end process pPOF_LED; + + pof_cnt_zero_flag <= '1' when unsigned(pof_cnt) = 0 else '0'; + + rst_pof_green <= '1' when one_ms_pulse = '1' and unsigned(pof_cnt) = END_GREEN_PERIOD_MS else '0'; + + led_pof_r <= '0'; + + + ----------------------------------------------------------------------------- + -- Emergency Flashing + ----------------------------------------------------------------------------- + + -- when the smb_ctrl watchdog is triggered (all_ok deasserted), all the LEDs + -- need to start flashing + + pEMERGENCY_FLASH : process(reset_n, clk) + begin + if (reset_n = '0') then + all_ok_d <= '0'; + alert_led <= "0000"; + alert_cnt <= std_logic_vector(to_unsigned(END_GREEN_PERIOD_MS - 1, alert_cnt'length)); + elsif (clk = '1' and clk'event) then + all_ok_d <= all_ok; + if (all_ok = '1') then + alert_led <= "0000"; + elsif (all_ok = '0' and all_ok_d = '1') then + alert_cnt <= std_logic_vector(to_unsigned(END_GREEN_PERIOD_MS - 1, alert_cnt'length)); + else + if (alert_cnt_zero_flag = '1') then + if (alert_led = "1111") then + alert_led <= "0000"; + else + alert_led <= alert_led(2 downto 0) & '1'; + end if; + alert_cnt <= std_logic_vector(to_unsigned(END_GREEN_PERIOD_MS - 1, alert_cnt'length)); + elsif (one_ms_pulse = '1') then + alert_cnt <= std_logic_vector(unsigned(alert_cnt) - 1); + end if; + end if; + end if; + end process pEMERGENCY_FLASH; + + alert_cnt_zero_flag <= '1' when unsigned(alert_cnt) = 0 else '0'; + + +end architecture rtl; diff --git a/generic_ip/fire_pulse_manager/8/src/simple_enc_vel_detect_8.vhd b/generic_ip/fire_pulse_manager/8/src/simple_enc_vel_detect_8.vhd new file mode 100644 index 0000000..1413680 --- /dev/null +++ b/generic_ip/fire_pulse_manager/8/src/simple_enc_vel_detect_8.vhd @@ -0,0 +1,76 @@ +------------------------------------------------------------------------------- +-- Title : simple encoder velocity detection +-- Project : project independent +------------------------------------------------------------------------------- +-- File : simple_enc_vel_detect_8.vhd +-- Author : Gianmarco Girau +-- Company : Global Inkjet Systems +-- Created : 2019-06-18 +-- Last update: 2020-04-16 +-- SVN ID : Git +-- Standard : VHDL'2008 +------------------------------------------------------------------------------- +-- Description: +-- This block detects encoder velocity by measuring the balance of encoder +-- positive and negative steps over consecutive sampling periods. +-- The sampling period is supposed to be less than 2 ms +------------------------------------------------------------------------------- +-- altera vhdl_input_version vhdl_2008 + + +library ieee; +use ieee.std_logic_1164.all; +use ieee.numeric_std.all; + +entity simple_enc_vel_detect_8 is + port ( + clk : in std_logic; -- Must be 100 MHz + init : in std_logic; + step_pos : in std_logic; + step_neg : in std_logic; + sampling_period : in std_logic_vector(19 downto 0); + vel_meas : out std_logic_vector(19 downto 0)); +end simple_enc_vel_detect_8; + +architecture RTL of simple_enc_vel_detect_8 is + + signal init_i, sampling_pulse : std_logic; + + signal sampling_per_cnt : std_logic_vector(19 downto 0); + signal vel_meas_i : std_logic_vector(19 downto 0); + signal vel_meas_sat_pos : std_logic_vector(19 downto 0); + signal vel_meas_sat_neg : std_logic_vector(19 downto 0); + +begin -- RTL + + pVEL_DETECT : process(clk) + begin + if(clk = '1' and clk'event) then + init_i <= init; + if(init_i = '1' or sampling_pulse = '1') then + sampling_per_cnt <= (others => '0'); + else + sampling_per_cnt <= std_logic_vector(unsigned(sampling_per_cnt)+1); + end if; + if(init_i = '1' or sampling_pulse = '1') then + vel_meas_i <= (others => '0'); + elsif(step_pos = '1' and signed(vel_meas_i) < signed(vel_meas_sat_pos)) then + vel_meas_i <= std_logic_vector(signed(vel_meas_i)+1); + elsif(step_neg = '1' and signed(vel_meas_i) > signed(vel_meas_sat_neg)) then + vel_meas_i <= std_logic_vector(signed(vel_meas_i)-1); + end if; + if(init_i = '1') then + vel_meas <= (others => '0'); + elsif(sampling_pulse = '1') then + vel_meas <= vel_meas_i; + end if; + end if; + end process pVEL_DETECT; + + sampling_pulse <= '1' when unsigned(sampling_per_cnt) = unsigned(sampling_period)-1 else '0'; + + -- define positive and negative saturation thresholds + vel_meas_sat_pos <= (vel_meas_i'left => '0', others => '1'); + vel_meas_sat_neg <= (vel_meas_i'left => '1', others => '0'); + +end RTL; diff --git a/generic_ip/fire_pulse_manager/8/src/test/fire_pulse_manager_8_one_tb.vhd b/generic_ip/fire_pulse_manager/8/src/test/fire_pulse_manager_8_one_tb.vhd new file mode 100644 index 0000000..4400a38 --- /dev/null +++ b/generic_ip/fire_pulse_manager/8/src/test/fire_pulse_manager_8_one_tb.vhd @@ -0,0 +1,826 @@ +------------------------------------------------------------------------------- +-- Title : fire_pulse_manager_one_tb +-- Project : fire_pulse_manager +------------------------------------------------------------------------------- +-- File : fire_pulse_manager_tb.vhd +-- Author : Christos Spirotis +-- Company : Global Inkjet Systems +-- Created : 2018-08-10 +-- Last update: 2020-04-20 +-- SVN ID : Git +-- Standard : VHDL'08 +------------------------------------------------------------------------------- +-- Description: +-- Testbench for fire pulse manager block with protocol version one +------------------------------------------------------------------------------- + +library ieee; +use ieee.std_logic_1164.all; +use ieee.numeric_std.all; +use ieee.math_real.all; + +use std.textio.all; + +use work.fire_pulse_8_pkg.all; +use work.fpm_ctrl_8_pkg.all; +use work.log_pkg.all; +use work.avalon_verify_pkg_2.all; +use work.pulse_generator_6_pkg.all; +use work.enc_pd_emul_3_pkg.all; +use work.fire_pulse_manager_8_one_tb_pkg.all; + +library osvvm; +use osvvm.RandomPkg.all; + +entity fire_pulse_manager_8_one_tb is +end fire_pulse_manager_8_one_tb; + +architecture behav of fire_pulse_manager_8_one_tb is + + constant NUM_AVS_DEVICES : integer := 2; + + constant AVS_ADDR_DUT : integer := 0; + constant AVS_ADDR_TB_POFTX : integer := 1; + constant RX_CLK_PERIOD : time := CLK_PERIOD / 3; -- clock period for used by the + -- UART-Rx on the POF + + constant POF_DELAY : time := 30 ns; -- Total delay from POF-Tx input to POF-Rx output + + constant ENC_PPR : natural := 10000; + constant ENC_FREQ : enc_freq_t := 1.0e6; + + constant PD_PULSE_W : pd_pulse_width_t := 0.5; + constant PD_PERIOD : pd_period_t := 2.0; + + constant NUM_ITERATIONS : natural := 5; + constant SWATHE_LEN : integer := 2000; + constant IMAGE_SIZE : integer := 100; + constant DIV_RATIO : real := 5.0; + constant SUBPIX_PHASES : integer := 5; + constant SEL_SUBPIX_PH : integer := 4; + constant START_DIR : enc_dir_t := DIR_0; + + + -- when DRIVE_DROP_WATCH is true, FPM output pof_tx is driven with the + -- drop-watch signal + constant DRIVE_DROP_WATCH : boolean := true; + + constant VERBOSITY_LEVEL : verb_level_t := VMEDIUM; + + type ch_offset_t is array (0 to CH_NUM - 1) of integer; + signal ch_offset : ch_offset_t := (others => 0); + + type fire_pulse_t is array (0 to CH_NUM - 1) of std_logic_vector(31 downto 0); + signal ch_fire_pulse : fire_pulse_t; + signal ch_start_of_image : fire_pulse_t; + + type avs_read_bus_t is array (0 to NUM_AVS_DEVICES - 1) of std_logic_vector(31 downto 0); + + signal reset_n : std_logic := '0'; + signal clk : std_logic := '0'; + signal rx_clk : std_logic := '0'; + signal dut_pof_tx, dut_pof_rx : std_logic; -- pof signals in and out of fpm. This TB does not check fpm output POF signal except as DW + signal fire_pulse : std_logic_vector(32 * CH_NUM - 1 downto 0); + signal start_of_image : std_logic_vector(32 * CH_NUM - 1 downto 0); + signal avs_address : std_logic_vector(14 downto 0); + signal avs_write : std_logic_vector(NUM_AVS_DEVICES - 1 downto 0); + signal avs_writedata : std_logic_vector(31 downto 0); + signal avs_read : std_logic_vector(NUM_AVS_DEVICES - 1 downto 0); + signal avs_readdata : avs_read_bus_t; + -- + signal tb_pof_tx_init_tx : std_logic; + signal inc_pos : std_logic; + signal dec_pos : std_logic; + signal abs_position : std_logic_vector(31 downto 0); + signal pof_tx_to_DUT_tx_data : std_logic; + signal enc_p1 : std_logic; + signal enc_p2 : std_logic; + signal pd : std_logic; + signal seb_epd_enc_p1 : std_logic; + signal seb_epd_enc_p2 : std_logic; + signal seb_epd_pd : std_logic; + -- + signal emul_address : std_logic_vector(9 downto 0); + signal emul_write : std_logic; + signal emul_writedata : std_logic_vector(31 downto 0); + signal emul_read : std_logic; + signal emul_readdata : std_logic_vector(31 downto 0); + signal emul_pos : std_logic_vector(39 downto 0); + -- + signal enc_dir : enc_dir_t; + signal swathe_cnt : integer; + signal half_swathe_cnt : integer; + signal swathe_pos : integer; + signal end_of_swathe : std_logic; + signal test_completed : boolean; + signal running : boolean; + signal configuring : boolean; + signal passed : boolean; + signal failed : boolean; + signal stimuli_completed : boolean; + -- + shared variable error_flag : boolean; + + signal registers_read : boolean := false; + signal reprogram_offset : boolean := false; + -- + signal avs_m : mm_m_rec_t; + signal avs_s : mm_s_rec_t; + signal sel_slave_DUT : std_logic; + signal sel_slave_TB_POFTX : std_logic; + signal emul_s : mm_s_rec_t; + signal emul_m : mm_m_rec_t; + -- + type pd_cnt_t is array (0 to CH_NUM - 1) of integer; + signal pd_cnt : pd_cnt_t; + type fp_cnt_t is array (0 to CH_NUM - 1) of integer; + signal fp_cnt : fp_cnt_t; + signal loc_fp_cnt : fp_cnt_t; + signal rst_fp_cnt : std_logic; + signal ch_pulse_out : std_logic_vector(CH_NUM - 1 downto 0); + signal ch_pulse_out_d : std_logic_vector(CH_NUM - 1 downto 0); + signal ch_start_of_img : std_logic_vector(CH_NUM - 1 downto 0); + -- + signal run_dw : std_logic; + signal dw : std_logic; + signal dw_d : std_logic; + signal dw_cnt : natural; + -- + signal input_mode : fpm_input_type_t; + -- + signal ext_pulse : std_logic; + signal ext_pulse_enable : std_logic; + signal fpm_abs_pos_out : std_logic_vector(31 downto 0); + signal fpm_print_start_rx : std_logic; + signal tb_pof_tx_print_start : std_logic := '1'; + signal tb_pof_tx_init_done : std_logic; + + +begin -- behav + + clk_pr : process + begin + clk <= '0'; + wait for 0.5 * CLK_PERIOD; + clk <= '1'; + wait for 0.5 * CLK_PERIOD; + end process clk_pr; + + rx_clk_pr : process + begin + rx_clk <= '0'; + wait for 0.5 * RX_CLK_PERIOD; + rx_clk <= '1'; + wait for 0.5 * RX_CLK_PERIOD; + end process rx_clk_pr; + + tb_pof_tx_print_start <= not tb_pof_tx_print_start after 39.7 us; + + ----------------------------------------------------------------------------- + -- DUTs : Fire Pulse Manager + ----------------------------------------------------------------------------- + + iDUT : entity work.fire_pulse_manager_8 + generic map( + SEB_EPD_MODE => true, + CH_NUM => CH_NUM, + PD_QUEUE_SIZE => 512, + ADD_EPD_DIAGS => false, + ADD_EVENT_LOGGER => false, + LOG_FIFO_SIZE => 1024, + PULSE_DELAY_EQUAL_EN => false, + TOF_COMP_EN => false, + PIXEL_PITCH_CORR_EN => false) + port map( + reset_n => reset_n, + clk => clk, + rx_clk => rx_clk, + pof_rx => dut_pof_rx, + pof_tx => dut_pof_tx, + pof_iso_en => open, + seb_epd_mode_en => open, + seb_epd_enc_p1 => seb_epd_enc_p1, + seb_epd_enc_p2 => seb_epd_enc_p2, + seb_epd_pd => seb_epd_pd, + fire_pulse => fire_pulse, + start_of_image => start_of_image, + stream_busy_a => open, + stream_busy_b => open, + dp_dir_out => open, + abs_pos_out => fpm_abs_pos_out, + print_start => fpm_print_start_rx, + mon_pt => open, + ins_fpm_irq_0 => open, + ins_fpm_irq_1 => open, + ins_fpm_irq_2 => open, + ins_fpm_irq_3 => open, + avs_address => avs_address, + avs_write => avs_write(AVS_ADDR_DUT), + avs_writedata => avs_writedata, + avs_read => avs_read(AVS_ADDR_DUT), + avs_readdata => avs_readdata(AVS_ADDR_DUT)); + + dut_pof_rx <= transport pof_tx_to_DUT_tx_data after POF_DELAY when ext_pulse_enable = '0' else ext_pulse; + + ----------------------------------------------------------------------------- + -- Split subpixel phases + ----------------------------------------------------------------------------- + + pSPLIT_SUBPIX_PH : process(all) + begin + for i in 0 to CH_NUM - 1 loop + ch_fire_pulse(i) <= fire_pulse(32 * i + 31 downto 32 * i); + ch_start_of_image(i) <= start_of_image(32 * i + 31 downto 32 * i); + ch_pulse_out(i) <= ch_fire_pulse(i)(0); + ch_start_of_img(i) <= ch_start_of_image(i)(SEL_SUBPIX_PH - 1); + end loop; -- i + end process pSPLIT_SUBPIX_PH; + + ----------------------------------------------------------------------------- + -- Encoder/PD emulator (Stimuli Generator) + ----------------------------------------------------------------------------- + + -- The Emulator provides the Encoder and PD stimuli to the FPM: + -- When using the SEB-POF, the encoder stimuli is given by the absolute position. + -- A POF-Transmitter block (below) encodes the Absolute position and PD + -- events according to the POF-Protocol format. + -- When using the SEB-EPD, the encoder phase-1/2 outputs of the emulator are + -- directly fed as inputs to the FPM + + iEMUL : entity work.enc_pd_emul_3 + port map( + clk => clk, + reset_n => reset_n, + ttl_pd => open, + ttl_enc_p1 => open, + ttl_enc_p2 => open, + ttl_enc_zp => open, + rs422_pd => pd, + rs422_enc_p1 => enc_p1, + rs422_enc_p2 => enc_p2, + rs422_enc_zp => open, + abs_pos_out => emul_pos, + set_pos_out => open, + inc_pos_out => inc_pos, + dec_pos_out => dec_pos, + avs_address => emul_address, + avs_write => emul_write, + avs_writedata => emul_writedata, + avs_read => emul_read, + avs_readdata => emul_readdata); + + abs_position <= emul_pos(31 downto 0); + + seb_epd_pd <= pd; + seb_epd_enc_p1 <= enc_p1; + seb_epd_enc_p2 <= enc_p2; + + ----------------------------------------------------------------------------- + -- POF Tx (Stimuli Generator) + ----------------------------------------------------------------------------- + + iPOF_TX : entity work.pof_tx_3 + + port map( + reset_n => reset_n, + clk => clk, + init => tb_pof_tx_init_tx, + init_done => tb_pof_tx_init_done, + pd_in => pd, + print_start => tb_pof_tx_print_start, + pof_protocol_version => '1', + inc_pos => inc_pos, + dec_pos => dec_pos, + abs_position => abs_position, + tx_data => pof_tx_to_DUT_tx_data, + avs_address => avs_address(2 downto 0), + avs_write => avs_write(AVS_ADDR_TB_POFTX), + avs_writedata => avs_writedata, + avs_read => avs_read(AVS_ADDR_TB_POFTX), + avs_readdata => avs_readdata(AVS_ADDR_TB_POFTX) + ); + + ----------------------------------------------------------------------------- + -- Stimuli Generation + ----------------------------------------------------------------------------- + + pSTIMULI : process + variable end_of_stimuli : boolean; + variable swathe_completed : boolean; + variable pd_pos : integer; + variable rv : RandomPType; + + begin + + -- initialization + tb_pof_tx_init_tx <= '0'; + enc_dir <= START_DIR; + swathe_pos <= 0; + -- + swathe_cnt <= 0; + half_swathe_cnt <= 0; + stimuli_completed <= false; + end_of_swathe <= '0'; + -- + mm_m_init(emul_m, use_readvalid => false); + + -- generating the stimulus + if (running /= true) then + wait until running = true; + end if; + wait for 200 ns; + + -- Set the initial absolute-position for the encoder emulator + set_enc_abs_pos(40x"0", emul_s, emul_m); + + -- Send a Init/Sync pulse to the POF-Tx + wait until clk = '1' and clk'event; + tb_pof_tx_init_tx <= '1'; + wait until clk = '1' and clk'event; + tb_pof_tx_init_tx <= '0'; + wait until rising_edge(tb_pof_tx_init_done); + wait for 500 ns; + + -- + -- generate the forward swathe + end_of_stimuli := false; + while end_of_stimuli = false loop + --swathe_pos <= 0; + + for i in 0 to CH_NUM - 1 loop + ch_offset(i) <= rv.RandInt(0, 199); + --ch_offset(i) <= 50; + end loop; + + -- handshake with pUUT_CTRL + reprogram_offset <= true; + wait until configuring = true; + reprogram_offset <= false; + wait until configuring = false; + + wait until clk = '1' and clk'event; + + -- start running the encoder + run_enc_pulses(ENC_FREQ, enc_dir, true, SWATHE_LEN, ENC_PPR, emul_s, emul_m); + if (enc_dir = DIR_0) then + log("Running Swathe " & to_string(swathe_cnt + 1) & ", DIR-0.", VMEDIUM); + else + log("Running Swathe " & to_string(swathe_cnt + 1) & ", DIR-1.", VMEDIUM); + end if; + + -- issue a PD to start periodic firing after a randomly selected initial offset + pd_pos := rv.RandInt(0, 49); + --pd_pos := 10; + for k in 1 to pd_pos loop + wait until abs_position'event; + end loop; -- k + run_pd_pulses(PD_PULSE_W, PD_PERIOD, true, emul_s, emul_m); + + swathe_completed := false; + while swathe_completed = false loop + wait for 500 ns; + -- Check whether the encoder generation has completed + check_max_pulses_done(swathe_completed, emul_s, emul_m); + end loop; + + wait for 25 us; + half_swathe_cnt <= half_swathe_cnt + 1; + + -- Signal to pOUT_CHECK_REGs + wait until clk = '1' and clk'event; + end_of_swathe <= '1'; + wait until clk = '1' and clk'event; + end_of_swathe <= '0'; + + -- reverse direction + if (enc_dir /= START_DIR) then + -- The number of iterations is doubled, to take into account POF and + -- EPD input types + if (swathe_cnt = 2 * NUM_ITERATIONS - 1) then + -- ************************************************************************** + end_of_stimuli := true; -- This will terminate the loop of swathe generations + -- ************************************************************************** + else + swathe_cnt <= swathe_cnt + 1; + end if; + end if; + + if (end_of_stimuli = false) then + wait until clk = '1' and clk'event; + if (enc_dir = DIR_0) then + enc_dir <= DIR_1; + else + enc_dir <= DIR_0; + end if; + + -- Wait some time to make sure the change of direction is transmitted. + -- Note: if the position starts changing before the receiver was able to + -- confirm the change of direction, then some encoder pulses may not be + -- generated + wait for 1 us; + wait until clk = '1' and clk'event; + end if; + end loop; -- end_of_stimuli = false + + -- Signal to pTB_CTRL and pUUT_CTRL + stimuli_completed <= true; + wait; + + end process pSTIMULI; + + -- + pGEN_EXT_PULSE : process + begin + ext_pulse <= '0'; + if ext_pulse_enable = '0' then + wait until ext_pulse_enable = '1'; + end if; + wait for 200 ns; + for n in 0 to 11 loop + ext_pulse <= '1'; + if n = 5 or n = 6 then + wait for 170 ns; + ext_pulse <= '0'; + wait for 30 ns; + else + wait for 200 ns; + ext_pulse <= '0'; + end if; + wait for 800 ns; + end loop; -- n + if ext_pulse_enable = '1' then + wait until ext_pulse_enable = '0'; + end if; + end process pGEN_EXT_PULSE; + + ----------------------------------------------------------------------------- + -- Testbench Control + ----------------------------------------------------------------------------- + + dw <= dut_pof_tx when run_dw = '1' else '0'; + + pOUT_CHECK_REGs : process(reset_n, clk) + begin + if (reset_n = '0') then + ch_pulse_out_d <= (others => '0'); + loc_fp_cnt <= (others => 0); + dw_d <= '0'; + dw_cnt <= 0; + elsif (clk = '1' and clk'event) then + ch_pulse_out_d <= ch_pulse_out; + for n in 0 to CH_NUM - 1 loop + if (rst_fp_cnt = '1') then + loc_fp_cnt(n) <= 0; + elsif (ch_pulse_out(n) = '1' and ch_pulse_out_d(n) = '0') then + loc_fp_cnt(n) <= loc_fp_cnt(n) + 1; + end if; + end loop; -- n + -- Check the number of generated fire-requests at the end of the swathe + if (end_of_swathe = '1') then + for n in 0 to CH_NUM - 1 loop + if (loc_fp_cnt(n) /= half_swathe_cnt * IMAGE_SIZE) then + log("ERROR on Channel CH" & integer'image(n) & ": Expected Fire-Requests = " & to_string(half_swathe_cnt * IMAGE_SIZE) & ", detected Fire-Requests = " & to_string(loc_fp_cnt(n)), VLOW, true); + error_flag := true; + end if; + end loop; -- n + end if; + dw_d <= dw; + if (run_dw = '0') then + dw_cnt <= 0; + elsif (dw = '1' and dw_d = '0') then + dw_cnt <= dw_cnt + 1; + end if; + end if; + end process pOUT_CHECK_REGs; + + pCHECK_PRINT_START : process + variable time_variable : time; + begin + + while stimuli_completed = false loop + wait until (tb_pof_tx_print_start'event or stimuli_completed); + time_variable := now; + for i in 1 to 6 loop + wait until (seb_epd_enc_p1'event or stimuli_completed); + if (stimuli_completed) then + exit; + end if; + end loop; + time_variable := now - time_variable; + if time_variable <= tb_pof_tx_print_start'last_event then + if fpm_print_start_rx /= tb_pof_tx_print_start then + log("FPM Print Start not aligned with driven value @ " & time'image(now), VLOW, true); + error_flag := true; + end if; + end if; + + if (stimuli_completed) then + exit; + end if; + + + end loop; + wait; + + end process pCHECK_PRINT_START; + + pTB_CTRL : process + type fp_arrived_t is array (0 to CH_NUM - 1) of boolean; + variable fp_arrived : fp_arrived_t; + type fp_arrived_pos_t is array (0 to CH_NUM - 1) of integer; + variable fp_arrived_pos : fp_arrived_pos_t; + variable fp_arrived_agg : integer; + variable pd_arrived_pos : integer; + alias pd_spy is <>; + alias abs_spy is <>; + + begin + + -- Set the verbosity level for logging + set_log_verbosity(VERBOSITY_LEVEL); + --set_log_verbosity(VHIGH); + + log_header("Multi-channel FPM verification:", VLOW); + + running <= false; + passed <= false; + + error_flag := false; + + -- Reset + reset_n <= '0'; + wait for 100 ns; + wait until clk = '1' and clk'event; + reset_n <= '1'; + + if (configuring /= true) then + wait until configuring = true; + end if; + wait until configuring = false; + running <= true; + + while stimuli_completed = false loop + wait until ((pd_spy = '1' and pd_spy'event) or stimuli_completed); + + if (stimuli_completed) then + exit; + end if; + + pd_arrived_pos := to_integer(signed(abs_spy)); + for i in 0 to CH_NUM - 1 loop + fp_arrived(i) := false; + fp_arrived_pos(i) := 0; + end loop; + log("Product detect fired @ " & integer'image(pd_arrived_pos) & " ... ", VLOW, true); + fp_arrived_agg := 0; + while fp_arrived_agg < CH_NUM loop + fp_arrived_agg := 0; + for i in 0 to CH_NUM - 1 loop + if fp_arrived(i) = true then + fp_arrived_agg := fp_arrived_agg + 1; + end if; + end loop; + + wait until (unsigned(ch_pulse_out) /= 0 or stimuli_completed); + if (stimuli_completed) then + exit; + end if; + + for i in 0 to CH_NUM - 1 loop + if ch_pulse_out(i) = '1' and fp_arrived(i) = false then + fp_arrived(i) := true; + fp_arrived_pos(i) := to_integer(signed(abs_spy)); + log("Channel CH" & integer'image(i) & " Fire pulse logged @ " & integer'image(fp_arrived_pos(i)) & " ... ", VLOW, true); + if (abs (pd_arrived_pos - fp_arrived_pos(i)) /= ch_offset(i)) then + log("ERROR on Channel CH" & integer'image(i) & ": First Fire-Pulse detected at position " & to_string(fp_arrived_pos(i)) & ", expected position is " & to_string((pd_arrived_pos + ch_offset(i))), VLOW, true); + error_flag := true; + end if; + end if; + end loop; + end loop; + end loop; + + if (stimuli_completed = true) then + -- wait enough time to make sure that a max length package can be propagated + wait for 20 us; + end if; + + if (registers_read = false) then + -- Signal from pUUT_CTRL + wait until registers_read = true; + end if; + + -- Report PD and FP counter from pulse generator + for i in 0 to CH_NUM - 1 loop + log("Channel CH" & integer'image(i) & " PD-in counter value : " & integer'image(pd_cnt(i)) & " ... ", VLOW, true); + log("Channel CH" & integer'image(i) & " FP-out counter value : " & integer'image(fp_cnt(i)) & " ... ", VLOW, true); + log("Channel CH" & integer'image(i) & " Detected Fire-Pulses : " & integer'image(loc_fp_cnt(i)) & " ... ", VLOW, true); + if (pd_cnt(i) /= (NUM_ITERATIONS) * 2 * 2) then -- fire_pulse_manager now has no registers beyond channel 0 + log("Channel CH" & integer'image(i) & " PD_cnt counter value Incorrect: ", VLOW, true); + error_flag := true; + end if; + if ((loc_fp_cnt(i) /= (NUM_ITERATIONS) * 2 * 2 * IMAGE_SIZE) or (fp_cnt(i) /= (NUM_ITERATIONS) * 2 * 2 * IMAGE_SIZE)) then + log("Channel CH" & integer'image(i) & " FP_cnt counter value Incorrect: ", VLOW, true); + error_flag := true; + end if; + end loop; + + wait until clk = '1' and clk'event; + + running <= false; + passed <= true after 100 ns; + wait; + + end process pTB_CTRL; + + pFAILED : process + begin + failed <= false; + while true loop + wait for 1 us; + if (error_flag = true) then + failed <= true; + end if; + end loop; + end process pFAILED; + + pREPORT_RESULT : process + begin + wait until failed = true or passed = true; + wait for 1 us; + log_separator_line(VLOW); + if (failed = true) then + log("FAILURE: test completed with errors.", VLOW); + elsif (passed = true) then + log("SUCCESS: test successfully completed.", VLOW); + end if; + log_separator_line(VLOW); + test_completed <= true; + end process pREPORT_RESULT; + + pUUT_CTRL : process + variable addr : std_logic_vector(31 downto 0) := (others => '0'); + variable data : std_logic_vector(31 downto 0) := (others => '0'); + + begin + sel_slave_DUT <= '0'; + sel_slave_TB_POFTX <= '0'; + rst_fp_cnt <= '0'; + configuring <= true; + + input_mode <= POF_INPUT; + + run_dw <= '0'; + + -- Initialize avalon mm interfaces + mm_m_init(avs_m, use_waitrequest => false); + + if (reset_n = '0') then + wait until reset_n = '1'; + wait for 100 ns; + wait until clk = '1' and clk'event; + end if; + + log("Driving external pulses ... ", VLOW, true); + ext_pulse_enable <= '1'; + wait for 20 us; + ext_pulse_enable <= '0'; + wait for 1 us; + wait until clk = '1' and clk'event; + -- signal to pOUT_CHECK_REGs to reset its own count + rst_fp_cnt <= '1'; + wait until clk = '1' and clk'event; + rst_fp_cnt <= '0'; + + log("Configuring POFTX ... ", VLOW, true); + sel_slave_TB_POFTX <= '1'; + -- enable the block + addr := std_logic_vector(to_unsigned(0, 32)); + data := X"0000_0021"; + mm_32b_write(addr, data, avs_s, avs_m); + + sel_slave_TB_POFTX <= '0'; + sel_slave_DUT <= '1'; + wait until clk = '1' and clk'event; + + log("Configuring FPM (DUT) ... ", VLOW, true); + + fpm_ctrl_config(avs_s, avs_m); + + fpm_ems_config(avs_s, avs_m); + + config_pg_l : for i in 0 to CH_NUM - 1 loop + + pulse_gen_config(i, ch_offset(i), DIV_RATIO, SUBPIX_PHASES, IMAGE_SIZE, avs_s, avs_m); + + end loop config_pg_l; + + log("Configuration completed.", VLOW, true); + configuring <= false; + + log_separator_line(VLOW); + log("POF input mode verification", VLOW, true); + log_separator_line(VLOW); + + fpm_input_config(input_mode, avs_s, avs_m); + + if (DRIVE_DROP_WATCH = true) then + drop_watch_config('1', "0001", 15, avs_s, avs_m); + end if; + + while stimuli_completed = false loop + wait until reprogram_offset = true or stimuli_completed = true; + if (stimuli_completed) then + exit; + end if; + + log("Reading counters ... ", VLOW, true); + -- Read PD and FP counter from pulse generator + for i in 0 to CH_NUM - 1 loop + fpm_reg_read(PG_CH_ID + i, work.pulse_generator_5_pkg.CSR_PD_COUNTER_ADDR, data, avs_s, avs_m); + pd_cnt(i) <= to_integer(unsigned(data)); + fpm_reg_read(PG_CH_ID + i, work.pulse_generator_5_pkg.CSR_FIRE_REQ_COUNTER_ADDR, data, avs_s, avs_m); + fp_cnt(i) <= to_integer(unsigned(data)); + wait until clk = '1' and clk'event; + log("CH-" & to_string(i) & ": pd_in_cnt = " & to_string(pd_cnt(i)) & ", fire_req_cnt = " & to_string(fp_cnt(i)) & ", detected fire-req-cnt = " & to_string(loc_fp_cnt(i)), VMEDIUM); + end loop; + + configuring <= true; + + -- Reprogram the input to EPD and repeat the same number of iterations + if (swathe_cnt = NUM_ITERATIONS) then + log_separator_line(VLOW); + log("EPD input mode verification", VLOW, true); + log_separator_line(VLOW); + + input_mode <= EPD_INPUT; + wait until clk = '1' and clk'event; + fpm_input_config(input_mode, avs_s, avs_m); + + if (DRIVE_DROP_WATCH = true) then + drop_watch_config('1', "0001", 15, avs_s, avs_m); + end if; + + run_dw <= '1'; + end if; + + log("Reprogramming offset ... ", VLOW, true); + config_of_l : for i in 0 to CH_NUM - 1 loop + ch_offset_config(i, ch_offset(i), avs_s, avs_m); + end loop; + configuring <= false; + end loop; + + log("Reading counters ... ", VLOW, true); + -- Read PD and FP counter from pulse generator + for i in 0 to CH_NUM - 1 loop + fpm_reg_read(PG_CH_ID + i, work.pulse_generator_5_pkg.CSR_PD_COUNTER_ADDR, data, avs_s, avs_m); + pd_cnt(i) <= to_integer(unsigned(data)); + fpm_reg_read(PG_CH_ID + i, work.pulse_generator_5_pkg.CSR_FIRE_REQ_COUNTER_ADDR, data, avs_s, avs_m); + fp_cnt(i) <= to_integer(unsigned(data)); + wait until clk = '1' and clk'event; + log("CH-" & to_string(i) & ": pd_in_cnt = " & to_string(pd_cnt(i)) & ", fire_req_cnt = " & to_string(fp_cnt(i)), VMEDIUM); + end loop; + + -- As a check that init can be sent safely. Needs visual inspection of transcript and waveform + fpm_init(avs_s, avs_m); + + wait for 1 us; + fpm_init(avs_s, avs_m); + + wait for 1 us; + registers_read <= true; + + + wait; + end process pUUT_CTRL; + + clk_clk <= clk; + reset_reset_n <= reset_n; + + avs_s.mm_readdata <= avs_readdata(AVS_ADDR_DUT) when sel_slave_DUT = '1' else + avs_readdata(AVS_ADDR_TB_POFTX) when sel_slave_TB_POFTX = '1' else (others => '0'); + + avs_s.mm_readdatavalid <= '0'; + + avs_s.mm_waitrequest <= '0'; + + avs_address <= avs_m.mm_address(avs_address'range); + avs_write(AVS_ADDR_DUT) <= avs_m.mm_write and sel_slave_DUT; + avs_write(AVS_ADDR_TB_POFTX) <= avs_m.mm_write and sel_slave_TB_POFTX; + avs_writedata <= avs_m.mm_writedata; + avs_read(AVS_ADDR_DUT) <= avs_m.mm_read and sel_slave_DUT; + avs_read(AVS_ADDR_TB_POFTX) <= avs_m.mm_read and sel_slave_TB_POFTX; + + -- Emulator Avalon bus maapings + emul_s.mm_readdata <= emul_readdata; + emul_s.mm_readdatavalid <= '0'; + emul_s.mm_waitrequest <= '0'; + + emul_address <= emul_m.mm_address(emul_address'range); + emul_writedata <= emul_m.mm_writedata; + emul_write <= emul_m.mm_write; + emul_read <= emul_m.mm_read; + +end behav; + diff --git a/generic_ip/fire_pulse_manager/8/src/test/fire_pulse_manager_8_one_tb_pkg.vhd b/generic_ip/fire_pulse_manager/8/src/test/fire_pulse_manager_8_one_tb_pkg.vhd new file mode 100644 index 0000000..cf83b72 --- /dev/null +++ b/generic_ip/fire_pulse_manager/8/src/test/fire_pulse_manager_8_one_tb_pkg.vhd @@ -0,0 +1,869 @@ +------------------------------------------------------------------------------- +-- Title : fire_pulse_manager_8_one_tb_pkg +-- Project : SMB +------------------------------------------------------------------------------- +-- File : fire_pulse_manager_8_one_tb_pkg.vhd +-- Author : Gianmarco Girau +-- Company : Global Inkjet Systems +-- Created : 2020-01-02 +-- Last update: 2021-01-06 +-- SVN ID : Git +-- Standard : VHDL'2008 +------------------------------------------------------------------------------- +-- Description: +-- Support package for the FPM testbench +------------------------------------------------------------------------------- + +--library std; +--use std.textio.all; + +library ieee; +use ieee.std_logic_1164.all; +use ieee.std_logic_textio.all; +use ieee.numeric_std.all; +use ieee.math_real.all; + +library work; +use work.fire_pulse_8_pkg.all; +use work.ems_1_pkg.all; +use work.fpm_ctrl_8_pkg.all; + +library OSVVM; +use OSVVM.RandomBasePkg.all; +use OSVVM.RandomPkg.all; + +library work; +use work.log_pkg.all; +use work.avalon_verify_pkg_2.all; +use work.enc_pd_emul_3_pkg.all; + +package fire_pulse_manager_8_one_tb_pkg is + + constant CLK_PERIOD : time := 10.0 ns; + constant CLK_FREQ : real := 100.0e6; + + constant CH_NUM : integer := 4; + constant BLK_NUM : natural := 6 + CH_NUM; + + constant ENC_NCO_WIDTH : positive := 32; + + -- Logging Verbosity Level + constant VERBOSITY_LEVEL : verb_level_t := VMEDIUM; + + type fpm_input_type_t is (POF_INPUT, EPD_INPUT, INTERNAL); + + ----------------------------------------------------------------------------- + -- FPM Configuration + ----------------------------------------------------------------------------- + + -- fpm_reg_write with addr defined as std_logic_vector + procedure fpm_reg_write( + blk_id : in natural range 0 to BLK_NUM-1; + addr : in std_logic_vector; + data : in std_logic_vector(31 downto 0); + signal mm_s : in mm_s_rec_t; + signal mm_m : out mm_m_rec_t); + + -- fpm_reg_write with addr defined as integer + procedure fpm_reg_write( + blk_id : in natural range 0 to BLK_NUM-1; + addr : in integer; + data : in std_logic_vector(31 downto 0); + signal mm_s : in mm_s_rec_t; + signal mm_m : out mm_m_rec_t); + + -- fpm_reg_read with addr defined as std_logic_vector + procedure fpm_reg_read( + blk_id : in natural range 0 to BLK_NUM-1; + addr : in std_logic_vector; + data : out std_logic_vector(31 downto 0); + signal mm_s : in mm_s_rec_t; + signal mm_m : out mm_m_rec_t); + + -- fpm_reg_read with addr defined as integer + procedure fpm_reg_read( + blk_id : in natural range 0 to BLK_NUM-1; + addr : in integer; + data : out std_logic_vector(31 downto 0); + signal mm_s : in mm_s_rec_t; + signal mm_m : out mm_m_rec_t); + + procedure fpm_ctrl_config( + signal mm_s : in mm_s_rec_t; + signal mm_m : out mm_m_rec_t); + + procedure ch_offset_config( + ch_id : in natural; + ch_offset : in natural; + signal mm_s : in mm_s_rec_t; + signal mm_m : out mm_m_rec_t); + + procedure ch_ctrl_config( + ch_id : in natural; + pixel_num : in natural; + signal mm_s : in mm_s_rec_t; + signal mm_m : out mm_m_rec_t); + + procedure pulse_gen_config( + ch_id : in natural; + ch_offset : in natural; + div_ratio : in real; + subpix_phases : in natural; + pixel_num : in natural; + signal mm_s : in mm_s_rec_t; + signal mm_m : out mm_m_rec_t); + + procedure fpm_init( + signal mm_s : in mm_s_rec_t; + signal mm_m : out mm_m_rec_t); + + procedure fpm_input_config( + input_type : in fpm_input_type_t; + signal mm_s : in mm_s_rec_t; + signal mm_m : out mm_m_rec_t); + + procedure fpm_ems_config( + signal mm_s : in mm_s_rec_t; + signal mm_m : out mm_m_rec_t); + + procedure drop_watch_config( + enable : in std_logic; + src : in std_logic_vector(3 downto 0); + pulse_witdth : in natural; + signal mm_s : in mm_s_rec_t; + signal mm_m : out mm_m_rec_t); + + ----------------------------------------------------------------------------- + -- ENC/PD Emulator Configuration + ----------------------------------------------------------------------------- + + type enc_phase_t is (SINGLE_PHASE, DUAL_PHASE); + type enc_edge_t is (RISING, FALLING, RISING_AND_FALLING); + type pd_edge_t is (RISING, FALLING, RISING_AND_FALLING); + subtype enc_freq_t is real range 0.0e3 to 10.0e6; + subtype pd_pulse_width_t is real range 0.0 to 1000.0; -- PD period in us + --subtype pd_period_t is real range 50.0 to 1.0e6; -- PD period in us + subtype pd_period_t is real range 0.5 to 1.0e6; -- PD period in us + + type enc_dir_t is (DIR_0, DIR_1); + + type emul_cfg_t is record + + enc_res : real; + enc_ppr : integer; + enc_phase : enc_phase_t; + enc_edge : enc_edge_t; + enc_dir : enc_dir_t; + pd_edge : pd_edge_t; + enc_freq : enc_freq_t; + pd_pulse_w : pd_pulse_width_t; + pd_period : pd_period_t; + enc_pulses : integer; + + end record emul_cfg_t; + + -- set abs-pos + procedure set_enc_abs_pos( + abs_pos : in std_logic_vector(39 downto 0); + signal mm_s_rec : in mm_s_rec_t; + signal mm_m_rec : out mm_m_rec_t); + + -- The ENC/PD emulator configuration is derived from the EMS + procedure apply_enc_pd_emul_cfg( + cfg : in emul_cfg_t; + init : in boolean := true; + run_pulses_mode : in boolean := false; + signal mm_s_rec : in mm_s_rec_t; + signal mm_m_rec : out mm_m_rec_t); + + -- Stop the ENC/PD emulator + procedure stop_enc_pd_emul( + signal mm_s_rec : in mm_s_rec_t; + signal mm_m_rec : out mm_m_rec_t); + + procedure check_max_pulses_done( + done : out boolean; + signal mm_s_rec : in mm_s_rec_t; + signal mm_m_rec : out mm_m_rec_t); + + -- Run a fix number of encoder pulses + procedure run_enc_pulses( + enc_freq : in enc_freq_t; + direction : in enc_dir_t; + double_ph_mode : in boolean := true; + num_pulses : in integer; + enc_ppr : in integer; + signal mm_s_rec : in mm_s_rec_t; + signal mm_m_rec : out mm_m_rec_t); + + -- Run PD pulses: either single pulse or periodic mode + procedure run_pd_pulses( + pulse_width : in pd_pulse_width_t; + pd_period : in pd_period_t; + single_pulse_mode : in boolean := false; + signal mm_s_rec : in mm_s_rec_t; + signal mm_m_rec : out mm_m_rec_t); + + ----------------------------------------------------------------------------- + -- Support functions + ----------------------------------------------------------------------------- + + -- generate the NCO increment corresponding to a given output frequency + function freq2NCO_inc( + f_out : real; f_clk : real) return std_logic_vector; + +end fire_pulse_manager_8_one_tb_pkg; + +package body fire_pulse_manager_8_one_tb_pkg is + + ----------------------------------------------------------------------------- + -- FPM Configuration + ----------------------------------------------------------------------------- + + -- fpm_reg_write with addr defined as std_logic_vector + procedure fpm_reg_write( + blk_id : in natural range 0 to BLK_NUM-1; + addr : in std_logic_vector; + data : in std_logic_vector(31 downto 0); + signal mm_s : in mm_s_rec_t; + signal mm_m : out mm_m_rec_t) is + + variable address : std_logic_vector(31 downto 0); + + begin + + address := std_logic_vector(to_unsigned(blk_id * BLK_SIZE + to_integer(unsigned(addr)), 32)); + mm_32b_write(address, data, mm_s, mm_m); + + end procedure fpm_reg_write; + + -- fpm_reg_write with addr defined as integer + procedure fpm_reg_write( + blk_id : in natural range 0 to BLK_NUM-1; + addr : in integer; + data : in std_logic_vector(31 downto 0); + signal mm_s : in mm_s_rec_t; + signal mm_m : out mm_m_rec_t) is + + variable address : std_logic_vector(31 downto 0); + + begin + + address := std_logic_vector(to_unsigned((blk_id * BLK_SIZE) + addr, 32)); + mm_32b_write(address, data, mm_s, mm_m); + + end procedure fpm_reg_write; + + -- fpm_reg_read with addr defined as std_logic_vector + procedure fpm_reg_read( + blk_id : in natural range 0 to BLK_NUM-1; + addr : in std_logic_vector; + data : out std_logic_vector(31 downto 0); + signal mm_s : in mm_s_rec_t; + signal mm_m : out mm_m_rec_t) is + + variable address : std_logic_vector(31 downto 0); + + begin + + address := std_logic_vector(to_unsigned(blk_id * BLK_SIZE + to_integer(unsigned(addr)), 32)); + mm_32b_read(address, data, mm_s, mm_m); + + end procedure fpm_reg_read; + + -- fpm_reg_read with addr defined as std_logic_vector + procedure fpm_reg_read( + blk_id : in natural range 0 to BLK_NUM-1; + addr : in integer; + data : out std_logic_vector(31 downto 0); + signal mm_s : in mm_s_rec_t; + signal mm_m : out mm_m_rec_t) is + + variable address : std_logic_vector(31 downto 0); + + begin + + address := std_logic_vector(to_unsigned((blk_id * BLK_SIZE) + addr, 32)); + mm_32b_read(address, data, mm_s, mm_m); + + end procedure fpm_reg_read; + + procedure fpm_ctrl_config( + signal mm_s : in mm_s_rec_t; + signal mm_m : out mm_m_rec_t) is + + variable data : std_logic_vector(31 downto 0); + + begin + + log("Configuring FPM Controller ... ", VMEDIUM, true); + -- Enable the POF-Rx and set protocol version 1 + data := X"0000_0101"; + fpm_reg_write(FP_CTRL_ID, CSR_POF_RECEIVER_CONTROL_ADDR_INT, data, mm_s, mm_m); + + fpm_reg_read(FP_CTRL_ID, CSR_SIGNAL_SELECTION_ADDR_INT, data, mm_s, mm_m); + + -- Select the input source + data(2 downto 0) := b"001"; + fpm_reg_write(FP_CTRL_ID, CSR_SIGNAL_SELECTION_ADDR_INT, data, mm_s, mm_m); + + end procedure fpm_ctrl_config; + + procedure ch_offset_config( + ch_id : in natural; + ch_offset : in natural; + signal mm_s : in mm_s_rec_t; + signal mm_m : out mm_m_rec_t) is + + variable data : std_logic_vector(31 downto 0); + + begin + + -- Disable/Re-enable first the whole pulse_generator + data := std_logic_vector(to_unsigned(ch_offset, 32)); + fpm_reg_write(PG_CH_ID + ch_id, work.pulse_generator_5_pkg.CSR_PD_OFFSET_DIR_0_ADDR, data, mm_s, mm_m); + fpm_reg_write(PG_CH_ID + ch_id, work.pulse_generator_5_pkg.CSR_PD_OFFSET_DIR_1_ADDR, data, mm_s, mm_m); + + log("CH-" & to_string(ch_id) & ": PD offset configured to " & to_string(ch_offset) & ".", VMEDIUM); + + end procedure ch_offset_config; + + procedure ch_ctrl_config( + ch_id : in natural; + pixel_num : in natural; + signal mm_s : in mm_s_rec_t; + signal mm_m : out mm_m_rec_t) is + + variable data : std_logic_vector(31 downto 0); + variable ram_idx : natural; + variable ram_offset : natural; + + begin + + ram_offset := to_integer(unsigned(work.pulse_generator_5_pkg.SEQ_GENERIC_SEQUENCER_18_CHANNEL_ADDR)); + ram_idx := 0; + + -- Issue first an image on DIR-0, then on DIR-1 + -- Reset the vector output value + data := X"30000000"; + fpm_reg_write(PG_CH_ID + ch_id, ram_offset + ram_idx, data, mm_s, mm_m); + ram_idx := ram_idx + 1; + -- Enable Trigger Mask (All the triggers) + data := X"1000000F"; + fpm_reg_write(PG_CH_ID + ch_id, ram_offset + ram_idx, data, mm_s, mm_m); + ram_idx := ram_idx + 1; + -- Wait for a single PD event + data := X"20000001"; + fpm_reg_write(PG_CH_ID + ch_id, ram_offset + ram_idx, data, mm_s, mm_m); + ram_idx := ram_idx + 1; + -- Issue a request to generate 'pixel_num' fire requests + data := X"30" & std_logic_vector(to_unsigned(pixel_num, 16)) & X"24"; + fpm_reg_write(PG_CH_ID + ch_id, ram_offset + ram_idx, data, mm_s, mm_m); + ram_idx := ram_idx + 1; + data := X"30" & std_logic_vector(to_unsigned(pixel_num, 16)) & X"00"; + fpm_reg_write(PG_CH_ID + ch_id, ram_offset + ram_idx, data, mm_s, mm_m); + ram_idx := ram_idx + 1; + -- wait until the end of the image + data := X"23000001"; + fpm_reg_write(PG_CH_ID + ch_id, ram_offset + ram_idx, data, mm_s, mm_m); + ram_idx := ram_idx + 1; + -- Switch to DIR-1 + data := X"30000001"; + fpm_reg_write(PG_CH_ID + ch_id, ram_offset + ram_idx, data, mm_s, mm_m); + ram_idx := ram_idx + 1; + -- Wait for a single PD event + data := X"20000001"; + fpm_reg_write(PG_CH_ID + ch_id, ram_offset + ram_idx, data, mm_s, mm_m); + ram_idx := ram_idx + 1; + -- Issue a request to generate 'pixel_num' fire requests + data := X"30" & std_logic_vector(to_unsigned(pixel_num, 16)) & X"25"; + fpm_reg_write(PG_CH_ID + ch_id, ram_offset + ram_idx, data, mm_s, mm_m); + ram_idx := ram_idx + 1; + data := X"30" & std_logic_vector(to_unsigned(pixel_num, 16)) & X"01"; + fpm_reg_write(PG_CH_ID + ch_id, ram_offset + ram_idx, data, mm_s, mm_m); + ram_idx := ram_idx + 1; + -- wait until the end of the image + data := X"23000001"; + fpm_reg_write(PG_CH_ID + ch_id, ram_offset + ram_idx, data, mm_s, mm_m); + ram_idx := ram_idx + 1; + -- Jump to DIR-0 + data := X"C0000000"; + fpm_reg_write(PG_CH_ID + ch_id, ram_offset + ram_idx, data, mm_s, mm_m); + ram_idx := ram_idx + 1; + + end procedure ch_ctrl_config; + + procedure pulse_gen_config( + ch_id : in natural; + ch_offset : in natural; + div_ratio : in real; + subpix_phases : in natural; + pixel_num : in natural; + signal mm_s : in mm_s_rec_t; + signal mm_m : out mm_m_rec_t) is + + variable data : std_logic_vector(31 downto 0); + variable ratio_int : integer; + variable ratio_slv : std_logic_vector(33 downto 0); + + begin + + log("Configuring Channel " & to_string(ch_id) & " ... ", VMEDIUM, true); + + -- Disable/Re-enable first the whole pulse_generator + data := (others => '0'); + fpm_reg_write(PG_CH_ID + ch_id, work.pulse_generator_6_pkg.CSR_PULSE_GEN_CONTROL_W_ADDR, data, mm_s, mm_m); + data := (0 => '1', 16 => '1', others => '0'); + fpm_reg_write(PG_CH_ID + ch_id, work.pulse_generator_6_pkg.CSR_PULSE_GEN_CONTROL_W_ADDR, data, mm_s, mm_m); + + -- Disable/Re-enable the Channel Controller sequencer + data := (others => '0'); + fpm_reg_write(PG_CH_ID + ch_id, to_integer(unsigned(work.pulse_generator_6_pkg.CSR_GENERIC_SEQUENCER_19_CHANNEL_ADDR)) + 3, data, mm_s, mm_m); + data := (0 => '1', others => '0'); + fpm_reg_write(PG_CH_ID + ch_id, to_integer(unsigned(work.pulse_generator_6_pkg.CSR_GENERIC_SEQUENCER_19_CHANNEL_ADDR)) + 3, data, mm_s, mm_m); + + -- Set the number of sub-pixel phases + data := std_logic_vector(to_unsigned(subpix_phases, 32)); + fpm_reg_write(PG_CH_ID + ch_id, work.pulse_generator_6_pkg.CSR_SUBPIXEL_PHASE_NUM_ADDR, data, mm_s, mm_m); + + -- set the division ratio + ratio_int := integer((div_ratio / real(subpix_phases)) * real(2 ** 24)); + ratio_slv := std_logic_vector(to_unsigned(ratio_int, 34)); + -- Set the integer part of the div-ratio + data(31 downto 10) := (others => '0'); + data(9 downto 0) := ratio_slv(33 downto 24); + fpm_reg_write(PG_CH_ID + ch_id, work.pulse_generator_6_pkg.CSR_DIVIDER_RATIO_INT_ADDR, data, mm_s, mm_m); + data(31 downto 24) := (others => '0'); + data(23 downto 0) := ratio_slv(23 downto 0); + fpm_reg_write(PG_CH_ID + ch_id, work.pulse_generator_6_pkg.CSR_DIVIDER_RATIO_FRACTION_ADDR, data, mm_s, mm_m); + -- Disable/Enable the fractional divider + data := (others => '0'); + fpm_reg_write(PG_CH_ID + ch_id, work.pulse_generator_6_pkg.CSR_FRACTIONAL_DIVIDER_CONTROL_ADDR, data, mm_s, mm_m); + data := (0 => '1', others => '0'); + fpm_reg_write(PG_CH_ID + ch_id, work.pulse_generator_6_pkg.CSR_FRACTIONAL_DIVIDER_CONTROL_ADDR, data, mm_s, mm_m); + + -- configure the channel offset + ch_offset_config(ch_id, ch_offset, mm_s, mm_m); + + -- Configure the sequencer RAM + ch_ctrl_config(ch_id, pixel_num, mm_s, mm_m); + + -- Restart the sequencer + data := (others => '0'); + fpm_reg_write(PG_CH_ID + ch_id, work.pulse_generator_6_pkg.CSR_CHANNEL_CONTROLLER_CONTROL_W_ADDR, data, mm_s, mm_m); + data := (0 => '1', others => '0'); + fpm_reg_write(PG_CH_ID + ch_id, work.pulse_generator_6_pkg.CSR_CHANNEL_CONTROLLER_CONTROL_W_ADDR, data, mm_s, mm_m); + + end procedure pulse_gen_config; + + + procedure fpm_init( + signal mm_s : in mm_s_rec_t; + signal mm_m : out mm_m_rec_t) is + + variable data : std_logic_vector(31 downto 0) := (others => '0'); + + begin + + -- Set the init_start bit + data(0) := '1'; + fpm_reg_write(FP_CTRL_ID, work.fpm_ctrl_8_pkg.CSR_FPM_INIT_START_ADDR, data, mm_s, mm_m); + + wait for 1 us; + -- ReSet the init_start bit + data(0) := '0'; + fpm_reg_write(FP_CTRL_ID, work.fpm_ctrl_8_pkg.CSR_FPM_INIT_START_ADDR, data, mm_s, mm_m); + + for i in 1 to 10 loop + -- Check if init is complete + fpm_reg_read(FP_CTRL_ID, work.fpm_ctrl_8_pkg.CSR_FPM_INIT_DONE_ADDR, data, mm_s, mm_m); + if data(0) = '1' then + exit; + else + wait for 300 ns; + end if; + + end loop; + + if data(0) = '1' then + log("FPM INIT completed", VMEDIUM, true); + else + log("ERROR: FPM INIT never completed", V_LOW, true); + wait for 2 us; + end if; + + end procedure fpm_init; + + procedure fpm_input_config( + input_type : in fpm_input_type_t; + signal mm_s : in mm_s_rec_t; + signal mm_m : out mm_m_rec_t) is + + variable data : std_logic_vector(31 downto 0); + + begin + + + + if (input_type = POF_INPUT) then + + fpm_reg_read(FP_CTRL_ID, CSR_SIGNAL_SELECTION_ADDR_INT, data, mm_s, mm_m); + + data(2 downto 0) := b"001"; + fpm_reg_write(FP_CTRL_ID, CSR_SIGNAL_SELECTION_ADDR_INT, data, mm_s, mm_m); + log("FPM input set to POF. ", VLOW, true); + + elsif (input_type = EPD_INPUT) then + + data(2 downto 0) := b"101"; + fpm_reg_write(FP_CTRL_ID, CSR_SIGNAL_SELECTION_ADDR_INT, data, mm_s, mm_m); + log("FPM input set to EPD. ", VLOW, true); + + end if; + + end procedure fpm_input_config; + + + procedure fpm_ems_config( + signal mm_s : in mm_s_rec_t; + signal mm_m : out mm_m_rec_t) is + + variable data : std_logic_vector(31 downto 0); + + begin + + log("Configuring EMS ... ", VMEDIUM, true); + + -- EMS software init + fpm_reg_write(EMS_BLK_ID, work.ems_1_pkg.CSR_EMS_ENABLE_ADDR, 32x"1", mm_s, mm_m); + + -- disable the EMS during the configuration + fpm_reg_write(EMS_BLK_ID, work.ems_1_pkg.CSR_EMS_ENABLE_ADDR, 32x"0", mm_s, mm_m); + + -- apply EMS config + fpm_reg_write(EMS_BLK_ID, work.ems_1_pkg.CSR_EMS_CONFIG_ADDR, 32x"3E0", mm_s, mm_m); + + -- enable the EMS + fpm_reg_write(EMS_BLK_ID, work.ems_1_pkg.CSR_EMS_ENABLE_ADDR, 32x"E", mm_s, mm_m); + + end procedure fpm_ems_config; + + procedure drop_watch_config( + enable : in std_logic; + src : in std_logic_vector(3 downto 0); + pulse_witdth : in natural; + signal mm_s : in mm_s_rec_t; + signal mm_m : out mm_m_rec_t) is + + variable data : std_logic_vector(31 downto 0); + + begin + + -- configure the drop-watch + data := std_logic_vector(to_unsigned(pulse_witdth, 16)) & X"000" & src; + fpm_reg_write(FP_CTRL_ID, work.fpm_ctrl_8_pkg.CSR_DROP_WATCH_CONFIG_ADDR_INT, data, mm_s, mm_m); + + -- Enable/disable the drop-watch + fpm_reg_read(FP_CTRL_ID, work.fpm_ctrl_8_pkg.CSR_SIGNAL_SELECTION_ADDR_INT, data, mm_s, mm_m); + data(3) := enable; + fpm_reg_write(FP_CTRL_ID, work.fpm_ctrl_8_pkg.CSR_SIGNAL_SELECTION_ADDR_INT, data, mm_s, mm_m); + + if (enable = '1') then + log("Drop-Watch output enable on channel " & to_string(to_integer(unsigned(src))) & ".", VMEDIUM, true); + else + log("Drop-Watch output disabled.", VMEDIUM, true); + end if; + + end procedure drop_watch_config; + + ----------------------------------------------------------------------------- + -- ENC/PD Emulator Configuration + ----------------------------------------------------------------------------- + + procedure set_enc_abs_pos( + abs_pos : in std_logic_vector(39 downto 0); + signal mm_s_rec : in mm_s_rec_t; + signal mm_m_rec : out mm_m_rec_t) is + + variable addr : std_logic_vector(31 downto 0) := (others => '0'); + variable data : std_logic_vector(31 downto 0) := (others => '0'); + + begin + + -- set the value for MSBs + addr := std_logic_vector(resize(unsigned(CSR_POS_INIT_MSB_ADDR), 32)); + mm_32b_write(addr, 24x"0" & abs_pos(39 downto 32), mm_s_rec, mm_m_rec); + -- set the value for LSBs + addr := std_logic_vector(resize(unsigned(CSR_POS_INIT_LSB_ADDR), 32)); + mm_32b_write(addr, abs_pos(31 downto 0), mm_s_rec, mm_m_rec); + -- read back the encoder configuration, then apply the set_abs_pos control + -- bit + addr := std_logic_vector(resize(unsigned(CSR_ENC_CTRL_W_ADDR), 32)); + mm_32b_read(addr, data, mm_s_rec, mm_m_rec); + data(3) := '1'; + mm_32b_write(addr, data, mm_s_rec, mm_m_rec); + + log("Encoder/PD emulator abs-pos preset to " & to_string(to_integer(signed(abs_pos))) & ".", VMEDIUM); + + + end procedure set_enc_abs_pos; + + procedure apply_enc_pd_emul_cfg( + cfg : in emul_cfg_t; + init : in boolean := true; + run_pulses_mode : in boolean := false; + signal mm_s_rec : in mm_s_rec_t; + signal mm_m_rec : out mm_m_rec_t) is + + variable addr : std_logic_vector(31 downto 0) := (others => '0'); + variable data : std_logic_vector(31 downto 0) := (others => '0'); + variable data_check : std_logic_vector(31 downto 0) := (others => '0'); + -- + variable pd_low_period : real := 0.0; -- PD low period (ns) + variable pd_high_period : real := 0.0; -- PD high period (ns) + + begin + + -- Set the NCO inc: output freq + addr := std_logic_vector(resize(unsigned(CSR_ENC_NCO_INC_ADDR), 32)); + data := freq2NCO_inc(real(cfg.enc_freq), CLK_FREQ); + mm_32b_write(addr, data, mm_s_rec, mm_m_rec); + + -- set the max pulses register + addr := std_logic_vector(resize(unsigned(CSR_ENC_PULSE_NUM_ADDR), 32)); + data := std_logic_vector(to_unsigned(cfg.enc_pulses, 32)); + mm_32b_write(addr, data, mm_s_rec, mm_m_rec); + + -- set the zero-phase ppr number + addr := std_logic_vector(resize(unsigned(CSR_ENC_ZP_PPR_ADDR), 32)); + data := std_logic_vector(to_unsigned(cfg.enc_ppr, 32)); + mm_32b_write(addr, data, mm_s_rec, mm_m_rec); + + -- Enable only the necessary outputs: + if (cfg.enc_phase = DUAL_PHASE) then + data := 32x"FF"; + else + data := 32x"BB"; + end if; + addr := std_logic_vector(resize(unsigned(CSR_OUT_ENABLE_ADDR), 32)); + mm_32b_write(addr, data, mm_s_rec, mm_m_rec); + + addr := std_logic_vector(resize(unsigned(CSR_ENC_CTRL_W_ADDR), 32)); + if (init = true) then + mm_32b_write(addr, 32x"2", mm_s_rec, mm_m_rec); + end if; + + data := (others => '0'); + if (run_pulses_mode = true) then + data(4) := '1'; + end if; + if (cfg.enc_dir = DIR_0) then + data(2) := '0'; + else + data(2) := '1'; + end if; + + -- enable the encoder + data(0) := '1'; + mm_32b_write(addr, data, mm_s_rec, mm_m_rec); + + log("Encoder/PD emulator enabled.", VMEDIUM); + + end procedure apply_enc_pd_emul_cfg; + + -- Stop the ENC/PD emulator + procedure stop_enc_pd_emul( + signal mm_s_rec : in mm_s_rec_t; + signal mm_m_rec : out mm_m_rec_t) is + + variable addr : std_logic_vector(31 downto 0) := (others => '0'); + variable data : std_logic_vector(31 downto 0) := (others => '0'); + + begin + + -- Disable PD emulation + addr := std_logic_vector(resize(unsigned(CSR_PD_CTRL_ADDR), 32)); + mm_32b_read(addr, data, mm_s_rec, mm_m_rec); + data(0) := '0'; + mm_32b_write(addr, data, mm_s_rec, mm_m_rec); + + -- Disable Enc emulation + addr := std_logic_vector(resize(unsigned(CSR_ENC_CTRL_W_ADDR), 32)); + mm_32b_read(addr, data, mm_s_rec, mm_m_rec); + data(0) := '0'; + mm_32b_write(addr, data, mm_s_rec, mm_m_rec); + + end procedure stop_enc_pd_emul; + + -- Check whether the generation of a fixed number of encoder pulses has completed + procedure check_max_pulses_done( + done : out boolean; + signal mm_s_rec : in mm_s_rec_t; + signal mm_m_rec : out mm_m_rec_t) is + + variable addr : std_logic_vector(31 downto 0) := (others => '0'); + variable data : std_logic_vector(31 downto 0) := (others => '0'); + + begin + + addr := std_logic_vector(resize(unsigned(CSR_ENC_CTRL_R_ADDR), 32)); + mm_32b_read(addr, data, mm_s_rec, mm_m_rec); + + if (data(6) = '1') then + done := true; + else + done := false; + end if; + + end procedure check_max_pulses_done; + + -- Run a fix number of encoder pulses + procedure run_enc_pulses( + enc_freq : in enc_freq_t; + direction : in enc_dir_t; + double_ph_mode : in boolean := true; + num_pulses : in integer; + enc_ppr : in integer; + signal mm_s_rec : in mm_s_rec_t; + signal mm_m_rec : out mm_m_rec_t) is + + variable addr : std_logic_vector(31 downto 0) := (others => '0'); + variable data : std_logic_vector(31 downto 0) := (others => '0'); + variable data_check : std_logic_vector(31 downto 0) := (others => '0'); + + begin + + -- Set the NCO inc: output freq + addr := std_logic_vector(resize(unsigned(CSR_ENC_NCO_INC_ADDR), 32)); + data := freq2NCO_inc(real(enc_freq), CLK_FREQ); + mm_32b_write(addr, data, mm_s_rec, mm_m_rec); + + -- set the max pulses register + addr := std_logic_vector(resize(unsigned(CSR_ENC_PULSE_NUM_ADDR), 32)); + data := std_logic_vector(to_unsigned(num_pulses, 32)); + mm_32b_write(addr, data, mm_s_rec, mm_m_rec); + + -- set the zero-phase ppr number + addr := std_logic_vector(resize(unsigned(CSR_ENC_ZP_PPR_ADDR), 32)); + data := std_logic_vector(to_unsigned(enc_ppr, 32)); + mm_32b_write(addr, data, mm_s_rec, mm_m_rec); + + -- Enable only the necessary outputs: + if (double_ph_mode = true) then + data := 32x"FF"; + else + data := 32x"BB"; + end if; + addr := std_logic_vector(resize(unsigned(CSR_OUT_ENABLE_ADDR), 32)); + mm_32b_write(addr, data, mm_s_rec, mm_m_rec); + + addr := std_logic_vector(resize(unsigned(CSR_ENC_CTRL_W_ADDR), 32)); + data := (4 => '1', 5 => '1', others => '0'); + if (direction = DIR_0) then + data(2) := '0'; + else + data(2) := '1'; + end if; + + -- enable the encoder + data(0) := '1'; + mm_32b_write(addr, data, mm_s_rec, mm_m_rec); + + --log("Running encoder pulses ... ", VMEDIUM); + + end procedure run_enc_pulses; + + -- Run PD pulses: either single pulse or periodic mode + procedure run_pd_pulses( + pulse_width : in pd_pulse_width_t; + pd_period : in pd_period_t; + single_pulse_mode : in boolean := false; + signal mm_s_rec : in mm_s_rec_t; + signal mm_m_rec : out mm_m_rec_t) is + + variable addr : std_logic_vector(31 downto 0) := (others => '0'); + variable data : std_logic_vector(31 downto 0) := (others => '0'); + variable data_check : std_logic_vector(31 downto 0) := (others => '0'); + variable tmp_val : integer; + variable idx : integer; + variable loop_idx : integer; + + begin + + -- set the pulse width + addr := std_logic_vector(resize(unsigned(CSR_PD_PULSE_WIDTH_ADDR), 32)); + data := std_logic_vector(to_unsigned(integer(pulse_width * 100.0), 32)); + mm_32b_write(addr, data, mm_s_rec, mm_m_rec); + + -- No need to use the sequerncer for a single pulse + if (single_pulse_mode = true) then + addr := std_logic_vector(resize(unsigned(CSR_PD_CTRL_ADDR), 32)); + mm_32b_write(addr, 32x"3", mm_s_rec, mm_m_rec); + log("Issued single PD pulse. ", VMEDIUM); + return; + end if; + + -- Use the sequencer to generate periodic pulses (here the periodicity is + -- in time): First program the sequencer RAM with instructions to generate + -- pulses with the specified periodicity, then enable the sequencer, + -- finally trigger the start of the procedure: + + -- Write in the Emulator sequencer a simple procedure to issue PD pulses + addr := std_logic_vector(resize(unsigned(SEQ_GENERIC_SEQUENCER_19_ADDR) + 0, 32)); + mm_32b_write(addr, X"100000FF", mm_s_rec, mm_m_rec); -- Enable triggers + addr := std_logic_vector(resize(unsigned(SEQ_GENERIC_SEQUENCER_19_ADDR) + 1, 32)); + mm_32b_write(addr, X"30000000", mm_s_rec, mm_m_rec); -- All the outputs to zero + idx := 2; + loop_idx := idx; + if (pd_period >= 1.0) then + -- add a first trigger-wait instruction for 1-us pulses + addr := std_logic_vector(resize(unsigned(SEQ_GENERIC_SEQUENCER_19_ADDR) + idx, 32)); + tmp_val := integer(pd_period); + data := X"21000" & std_logic_vector(to_unsigned(tmp_val, 12)); + mm_32b_write(addr, data, mm_s_rec, mm_m_rec); -- trig_wait (us pulses) + idx := idx + 1; + end if; + -- add a second trigger on single clock cycle events + addr := std_logic_vector(resize(unsigned(SEQ_GENERIC_SEQUENCER_19_ADDR) + idx, 32)); + tmp_val := integer((pd_period - floor(pd_period)) * 100.0); + data := X"20000" & std_logic_vector(to_unsigned(tmp_val, 12)); + mm_32b_write(addr, data, mm_s_rec, mm_m_rec); -- trig_wait (clk pulses) + idx := idx + 1; + -- issue the PD pulse + addr := std_logic_vector(resize(unsigned(SEQ_GENERIC_SEQUENCER_19_ADDR) + idx, 32)); + mm_32b_write(addr, X"31000001", mm_s_rec, mm_m_rec); -- All the outputs to zero + idx := idx + 1; + -- Jump to the beginning of the loop + addr := std_logic_vector(resize(unsigned(SEQ_GENERIC_SEQUENCER_19_ADDR) + idx, 32)); + mm_32b_write(addr, X"31000001", mm_s_rec, mm_m_rec); -- All the outputs to zero + + -- Enable the sequencer + addr := std_logic_vector(resize(unsigned(SEQ_GENERIC_SEQUENCER_19_ADDR) + idx, 32)); + mm_32b_write(addr, 32x"1", mm_s_rec, mm_m_rec); -- All the outputs to zero + + -- issue a start-request to the sequencer + addr := std_logic_vector(resize(unsigned(CSR_SEQ_CTRL_ADDR), 32)); + data(0) := '1'; -- start-request bit + data(24 downto 16) := 9x"0"; -- EAM sequence start-address + mm_32b_write(addr, 32x"1", mm_s_rec, mm_m_rec); + + log("Running PD pulses ... ", VMEDIUM); + + end procedure run_pd_pulses; + + ----------------------------------------------------------------------------- + -- Support functions + ----------------------------------------------------------------------------- + + -- generate the NCO increment corresponding to a given output frequency + function freq2NCO_inc( + f_out : real; f_clk : real) return std_logic_vector is + variable nco_inc : std_logic_vector(ENC_NCO_WIDTH - 1 downto 0); + + begin + nco_inc := std_logic_vector(to_unsigned(integer((f_out / f_clk) * (2.0 ** ENC_NCO_WIDTH)), ENC_NCO_WIDTH)); + return nco_inc; + + end function freq2NCO_inc; + +end fire_pulse_manager_8_one_tb_pkg; diff --git a/generic_ip/fire_pulse_manager/8/src/test/fire_pulse_manager_8_tb.vhd b/generic_ip/fire_pulse_manager/8/src/test/fire_pulse_manager_8_tb.vhd new file mode 100644 index 0000000..9a2fbc2 --- /dev/null +++ b/generic_ip/fire_pulse_manager/8/src/test/fire_pulse_manager_8_tb.vhd @@ -0,0 +1,785 @@ +------------------------------------------------------------------------------- +-- Title : fire_pulse_manager_tb +-- Project : fire_pulse_manager +------------------------------------------------------------------------------- +-- File : fire_pulse_manager_tb.vhd +-- Author : Christos Spirotis +-- Company : Global Inkjet Systems +-- Created : 2018-08-10 +-- Last update: 2020-04-20 +-- SVN ID : Git +-- Standard : VHDL'08 +------------------------------------------------------------------------------- +-- Description: +-- Testbench for fire pulse manager block with protocol version zero +------------------------------------------------------------------------------- + +library ieee; +use ieee.std_logic_1164.all; +use ieee.numeric_std.all; +use ieee.math_real.all; + +use std.textio.all; + +use work.fire_pulse_8_pkg.all; +use work.fpm_ctrl_8_pkg.all; +use work.log_pkg.all; +use work.avalon_verify_pkg_2.all; +use work.pulse_generator_6_pkg.all; +use work.enc_pd_emul_3_pkg.all; +use work.fire_pulse_manager_8_tb_pkg.all; + +library osvvm; +use osvvm.RandomPkg.all; + +entity fire_pulse_manager_8_tb is +end fire_pulse_manager_8_tb; + +architecture behav of fire_pulse_manager_8_tb is + + constant NUM_AVS_DEVICES : integer := 2; + + constant AVS_ADDR_DUT : integer := 0; + constant AVS_ADDR_TB_POFTX : integer := 1; + + constant RX_CLK_PERIOD : time := CLK_PERIOD / 3; -- clock period for used by the + -- UART-Rx on the POF + + constant POF_DELAY : time := 30 ns; -- Total delay from POF-Tx input to POF-Rx output + + constant ENC_PPR : natural := 10000; + constant ENC_FREQ : enc_freq_t := 1.0e6; + + constant PD_PULSE_W : pd_pulse_width_t := 0.5; + constant PD_PERIOD : pd_period_t := 2.0; + + constant NUM_ITERATIONS : natural := 5; + constant SWATHE_LEN : integer := 2000; + constant IMAGE_SIZE : integer := 100; + constant DIV_RATIO : real := 5.0; + constant SUBPIX_PHASES : integer := 5; + constant SEL_SUBPIX_PH : integer := 4; + constant START_DIR : enc_dir_t := DIR_0; + + + -- when DRIVE_DROP_WATCH is true, FPM output pof_tx is driven with the + -- drop-watch signal + constant DRIVE_DROP_WATCH : boolean := true; + + constant VERBOSITY_LEVEL : verb_level_t := VMEDIUM; + + type ch_offset_t is array (0 to CH_NUM - 1) of integer; + signal ch_offset : ch_offset_t := (others => 0); + + type fire_pulse_t is array (0 to CH_NUM - 1) of std_logic_vector(31 downto 0); + signal ch_fire_pulse : fire_pulse_t; + signal ch_start_of_image : fire_pulse_t; + + type avs_read_bus_t is array (0 to NUM_AVS_DEVICES - 1) of std_logic_vector(31 downto 0); + + signal reset_n : std_logic := '0'; + signal clk : std_logic := '0'; + signal rx_clk : std_logic := '0'; + signal dut_pof_tx, dut_pof_rx : std_logic; -- pof signals in and out of fpm. This TB does not check fpm output POF signal except as DW + signal fire_pulse : std_logic_vector(32 * CH_NUM - 1 downto 0); + signal start_of_image : std_logic_vector(32 * CH_NUM - 1 downto 0); + signal avs_address : std_logic_vector(14 downto 0); + signal avs_write : std_logic_vector(NUM_AVS_DEVICES - 1 downto 0); + signal avs_writedata : std_logic_vector(31 downto 0); + signal avs_read : std_logic_vector(NUM_AVS_DEVICES - 1 downto 0); + signal avs_readdata : avs_read_bus_t; + -- + signal tb_fpm_init_tx : std_logic; + signal inc_pos : std_logic; + signal dec_pos : std_logic; + signal abs_position : std_logic_vector(31 downto 0); + signal pof_tx_to_DUT_tx_data : std_logic; + signal enc_p1 : std_logic; + signal enc_p2 : std_logic; + signal pd : std_logic; + signal seb_epd_enc_p1 : std_logic; + signal seb_epd_enc_p2 : std_logic; + signal seb_epd_pd : std_logic; + -- + signal emul_address : std_logic_vector(9 downto 0); + signal emul_write : std_logic; + signal emul_writedata : std_logic_vector(31 downto 0); + signal emul_read : std_logic; + signal emul_readdata : std_logic_vector(31 downto 0); + signal emul_pos : std_logic_vector(39 downto 0); + -- + signal enc_dir : enc_dir_t; + signal swathe_cnt : integer; + signal half_swathe_cnt : integer; + signal swathe_pos : integer; + signal end_of_swathe : std_logic; + signal test_completed : boolean; + signal running : boolean; + signal configuring : boolean; + signal passed : boolean; + signal failed : boolean; + signal stimuli_completed : boolean; + -- + shared variable error_flag : boolean; + + signal registers_read : boolean := false; + signal reprogram_offset : boolean := false; + -- + signal avs_m : mm_m_rec_t; + signal avs_s : mm_s_rec_t; + signal sel_slave_DUT : std_logic; + signal sel_slave_TB_POFTX : std_logic; + signal emul_s : mm_s_rec_t; + signal emul_m : mm_m_rec_t; + -- + type pd_cnt_t is array (0 to CH_NUM - 1) of integer; + signal pd_cnt : pd_cnt_t; + type fp_cnt_t is array (0 to CH_NUM - 1) of integer; + signal fp_cnt : fp_cnt_t; + signal loc_fp_cnt : fp_cnt_t; + signal rst_fp_cnt : std_logic; + signal ch_pulse_out : std_logic_vector(CH_NUM - 1 downto 0); + signal ch_pulse_out_d : std_logic_vector(CH_NUM - 1 downto 0); + signal ch_start_of_img : std_logic_vector(CH_NUM - 1 downto 0); + -- + signal run_dw : std_logic; + signal dw : std_logic; + signal dw_d : std_logic; + signal dw_cnt : natural; + -- + signal input_mode : fpm_input_type_t; + -- + signal ext_pulse : std_logic; + signal ext_pulse_enable : std_logic; + signal tb_fpm_init_done : std_logic; + signal fpm_print_start_rx : std_logic; + + +begin -- behav + + clk_pr : process + begin + clk <= '0'; + wait for 0.5 * CLK_PERIOD; + clk <= '1'; + wait for 0.5 * CLK_PERIOD; + end process clk_pr; + + rx_clk_pr : process + begin + rx_clk <= '0'; + wait for 0.5 * RX_CLK_PERIOD; + rx_clk <= '1'; + wait for 0.5 * RX_CLK_PERIOD; + end process rx_clk_pr; + + ----------------------------------------------------------------------------- + -- DUTs : Fire Pulse Manager + ----------------------------------------------------------------------------- + iDUT : entity work.fire_pulse_manager_8 + generic map( + SEB_EPD_MODE => true, + CH_NUM => CH_NUM) + port map( + reset_n => reset_n, + clk => clk, + rx_clk => rx_clk, + pof_rx => dut_pof_rx, + pof_tx => dut_pof_tx, + seb_epd_enc_p1 => seb_epd_enc_p1, + seb_epd_enc_p2 => seb_epd_enc_p2, + seb_epd_pd => seb_epd_pd, + fire_pulse => fire_pulse, + start_of_image => start_of_image, + print_start => fpm_print_start_rx, + mon_pt => open, + ins_fpm_irq_0 => open, + ins_fpm_irq_1 => open, + ins_fpm_irq_2 => open, + ins_fpm_irq_3 => open, + avs_address => avs_address, + avs_write => avs_write(AVS_ADDR_DUT), + avs_writedata => avs_writedata, + avs_read => avs_read(AVS_ADDR_DUT), + avs_readdata => avs_readdata(AVS_ADDR_DUT)); + + dut_pof_rx <= transport pof_tx_to_DUT_tx_data after POF_DELAY when ext_pulse_enable = '0' else ext_pulse; + + ----------------------------------------------------------------------------- + -- Split subpixel phases + ----------------------------------------------------------------------------- + + pSPLIT_SUBPIX_PH : process(all) + begin + for i in 0 to CH_NUM - 1 loop + ch_fire_pulse(i) <= fire_pulse(32 * i + 31 downto 32 * i); + ch_start_of_image(i) <= start_of_image(32 * i + 31 downto 32 * i); + ch_pulse_out(i) <= ch_fire_pulse(i)(0); + ch_start_of_img(i) <= ch_start_of_image(i)(SEL_SUBPIX_PH - 1); + end loop; -- i + end process pSPLIT_SUBPIX_PH; + + ----------------------------------------------------------------------------- + -- Encoder/PD emulator (Stimuli Generator) + ----------------------------------------------------------------------------- + + -- The Emulator provides the Encoder and PD stimuli to the FPM: + -- When using the SEB-POF, the encoder stimuli is given by the absolute position. + -- A POF-Transmitter block (below) encodes the Absolute position and PD + -- events according to the POF-Protocol format. + -- When using the SEB-EPD, the encoder phase-1/2 outputs of the emulator are + -- directly fed as inputs to the FPM + + iEMUL : entity work.enc_pd_emul_3 + port map( + clk => clk, + reset_n => reset_n, + ttl_pd => open, + ttl_enc_p1 => open, + ttl_enc_p2 => open, + ttl_enc_zp => open, + rs422_pd => pd, + rs422_enc_p1 => enc_p1, + rs422_enc_p2 => enc_p2, + rs422_enc_zp => open, + abs_pos_out => emul_pos, + set_pos_out => open, + inc_pos_out => inc_pos, + dec_pos_out => dec_pos, + avs_address => emul_address, + avs_write => emul_write, + avs_writedata => emul_writedata, + avs_read => emul_read, + avs_readdata => emul_readdata); + + abs_position <= emul_pos(31 downto 0); + + seb_epd_pd <= pd; + seb_epd_enc_p1 <= enc_p1; + seb_epd_enc_p2 <= enc_p2; + + ----------------------------------------------------------------------------- + -- POF Tx (Stimuli Generator) + ----------------------------------------------------------------------------- + + iPOF_TX : entity work.pof_tx_3 + + port map( + reset_n => reset_n, + clk => clk, + init => tb_fpm_init_tx, + init_done => tb_fpm_init_done, + pd_in => pd, + print_start => open, + pof_protocol_version => '0', + inc_pos => inc_pos, + dec_pos => dec_pos, + abs_position => abs_position, + tx_data => pof_tx_to_DUT_tx_data, + avs_address => avs_address(2 downto 0), + avs_write => avs_write(AVS_ADDR_TB_POFTX), + avs_writedata => avs_writedata, + avs_read => avs_read(AVS_ADDR_TB_POFTX), + avs_readdata => avs_readdata(AVS_ADDR_TB_POFTX) + ); + + ----------------------------------------------------------------------------- + -- Stimuli Generation + ----------------------------------------------------------------------------- + + pSTIMULI : process + variable end_of_stimuli : boolean; + variable swathe_completed : boolean; + variable pd_pos : integer; + variable rv : RandomPType; + + begin + + -- initialization + tb_fpm_init_tx <= '0'; + enc_dir <= START_DIR; + swathe_pos <= 0; + -- + swathe_cnt <= 0; + half_swathe_cnt <= 0; + stimuli_completed <= false; + end_of_swathe <= '0'; + -- + mm_m_init(emul_m, use_readvalid => false); + + -- generating the stimulus + if (running /= true) then + wait until running = true; + end if; + wait for 200 ns; + + -- Set the initial absolute-position for the encoder emulator + set_enc_abs_pos(40x"0", emul_s, emul_m); + + -- Send a Init/Sync pulse to the POF-Tx in the test bench + wait until clk = '1' and clk'event; + tb_fpm_init_tx <= '1'; + wait until clk = '1' and clk'event; + tb_fpm_init_tx <= '0'; + wait until rising_edge(tb_fpm_init_done); + log("test bench's init_tx complete (sends init message to UUT over POF)", VMEDIUM); + + wait for 500 ns; + + -- + -- generate the forward swathe + end_of_stimuli := false; + while end_of_stimuli = false loop + --swathe_pos <= 0; + + for i in 0 to CH_NUM - 1 loop + ch_offset(i) <= rv.RandInt(0, 199); + --ch_offset(i) <= 50; + end loop; + + -- handshake with pUUT_CTRL + reprogram_offset <= true; + wait until configuring = true; + reprogram_offset <= false; + wait until configuring = false; + + wait until clk = '1' and clk'event; + + -- start running the encoder + run_enc_pulses(ENC_FREQ, enc_dir, true, SWATHE_LEN, ENC_PPR, emul_s, emul_m); + if (enc_dir = DIR_0) then + log("Running Swathe " & to_string(swathe_cnt + 1) & ", DIR-0.", VMEDIUM); + else + log("Running Swathe " & to_string(swathe_cnt + 1) & ", DIR-1.", VMEDIUM); + end if; + + -- issue a PD to start periodic firing after a randomly selected initial offset + pd_pos := rv.RandInt(0, 49); + --pd_pos := 10; + for k in 1 to pd_pos loop + wait until abs_position'event; + end loop; -- k + run_pd_pulses(PD_PULSE_W, PD_PERIOD, true, emul_s, emul_m); + + swathe_completed := false; + while swathe_completed = false loop + wait for 500 ns; + -- Check whether the encoder generation has completed + check_max_pulses_done(swathe_completed, emul_s, emul_m); + end loop; + + wait for 25 us; + half_swathe_cnt <= half_swathe_cnt + 1; + + -- Signal to pOUT_CHECK_REGs + wait until clk = '1' and clk'event; + end_of_swathe <= '1'; + wait until clk = '1' and clk'event; + end_of_swathe <= '0'; + + -- reverse direction + if (enc_dir /= START_DIR) then + -- The number of iterations is doubled, to take into account POF and + -- EPD input types + if (swathe_cnt = 2 * NUM_ITERATIONS - 1) then + -- ************************************************************************** + end_of_stimuli := true; -- This will terminate the loop of swathe generations + -- ************************************************************************** + else + swathe_cnt <= swathe_cnt + 1; + end if; + end if; + + if (end_of_stimuli = false) then + wait until clk = '1' and clk'event; + if (enc_dir = DIR_0) then + enc_dir <= DIR_1; + else + enc_dir <= DIR_0; + end if; + + -- Wait some time to make sure the change of direction is transmitted. + -- Note: if the position starts changing before the receiver was able to + -- confirm the change of direction, then some encoder pulses may not be + -- generated + wait for 1 us; + wait until clk = '1' and clk'event; + end if; + end loop; -- end_of_stimuli = false + + -- Signal to pTB_CTRL and pUUT_CTRL + stimuli_completed <= true; + wait; + + end process pSTIMULI; + + -- + pGEN_EXT_PULSE : process + begin + ext_pulse <= '0'; + if ext_pulse_enable = '0' then + wait until ext_pulse_enable = '1'; + end if; + wait for 200 ns; + for n in 0 to 11 loop + ext_pulse <= '1'; + if n = 5 or n = 6 then + wait for 170 ns; + ext_pulse <= '0'; + wait for 30 ns; + else + wait for 200 ns; + ext_pulse <= '0'; + end if; + wait for 800 ns; + end loop; -- n + if ext_pulse_enable = '1' then + wait until ext_pulse_enable = '0'; + end if; + end process pGEN_EXT_PULSE; + + ----------------------------------------------------------------------------- + -- Testbench Control + ----------------------------------------------------------------------------- + + dw <= dut_pof_tx when run_dw = '1' else '0'; + + pOUT_CHECK_REGs : process(reset_n, clk) + begin + if (reset_n = '0') then + ch_pulse_out_d <= (others => '0'); + loc_fp_cnt <= (others => 0); + dw_d <= '0'; + dw_cnt <= 0; + elsif (clk = '1' and clk'event) then + ch_pulse_out_d <= ch_pulse_out; + for n in 0 to CH_NUM - 1 loop + if (rst_fp_cnt = '1') then + loc_fp_cnt(n) <= 0; + elsif (ch_pulse_out(n) = '1' and ch_pulse_out_d(n) = '0') then + loc_fp_cnt(n) <= loc_fp_cnt(n) + 1; + end if; + end loop; -- n + -- Check the number of generated fire-requests at the end of the swathe + if (end_of_swathe = '1') then + for n in 0 to CH_NUM - 1 loop + if (loc_fp_cnt(n) /= half_swathe_cnt * IMAGE_SIZE) then + log("ERROR on Channel CH" & integer'image(n) & ": Expected Fire-Requests = " & to_string(half_swathe_cnt * IMAGE_SIZE) & ", detected Fire-Requests = " & to_string(loc_fp_cnt(n)), VLOW, true); + error_flag := true; + end if; + end loop; -- n + end if; + dw_d <= dw; + if (run_dw = '0') then + dw_cnt <= 0; + elsif (dw = '1' and dw_d = '0') then + dw_cnt <= dw_cnt + 1; + end if; + end if; + end process pOUT_CHECK_REGs; + + pTB_CTRL : process + type fp_arrived_t is array (0 to CH_NUM - 1) of boolean; + variable fp_arrived : fp_arrived_t; + type fp_arrived_pos_t is array (0 to CH_NUM - 1) of integer; + variable fp_arrived_pos : fp_arrived_pos_t; + variable fp_arrived_agg : integer; + variable pd_arrived_pos : integer; + alias pd_spy is <>; + alias abs_spy is <>; + + begin + + -- Set the verbosity level for logging + set_log_verbosity(VERBOSITY_LEVEL); + --set_log_verbosity(VHIGH); + + log_header("Multi-channel FPM verification:", VLOW); + + running <= false; + passed <= false; + + error_flag := false; + + -- Reset + reset_n <= '0'; + wait for 100 ns; + wait until clk = '1' and clk'event; + reset_n <= '1'; + + if (configuring /= true) then + wait until configuring = true; + end if; + wait until configuring = false; + running <= true; + + while stimuli_completed = false loop + wait until ((pd_spy = '1' and pd_spy'event) or stimuli_completed); + + if (stimuli_completed) then + exit; + end if; + + pd_arrived_pos := to_integer(signed(abs_spy)); + for i in 0 to CH_NUM - 1 loop + fp_arrived(i) := false; + fp_arrived_pos(i) := 0; + end loop; + log("Product detect fired @ " & integer'image(pd_arrived_pos) & " ... ", VLOW, true); + fp_arrived_agg := 0; + while fp_arrived_agg < CH_NUM loop + fp_arrived_agg := 0; + for i in 0 to CH_NUM - 1 loop + if fp_arrived(i) = true then + fp_arrived_agg := fp_arrived_agg + 1; + end if; + end loop; + + wait until (unsigned(ch_pulse_out) /= 0 or stimuli_completed); + if (stimuli_completed) then + exit; + end if; + + for i in 0 to CH_NUM - 1 loop + if ch_pulse_out(i) = '1' and fp_arrived(i) = false then + fp_arrived(i) := true; + fp_arrived_pos(i) := to_integer(signed(abs_spy)); + log("Channel CH" & integer'image(i) & " Fire pulse logged @ " & integer'image(fp_arrived_pos(i)) & " ... ", VLOW, true); + if (abs (pd_arrived_pos - fp_arrived_pos(i)) /= ch_offset(i)) then + log("ERROR on Channel CH" & integer'image(i) & ": First Fire-Pulse detected at position " & to_string(fp_arrived_pos(i)) & ", expected position is " & to_string((pd_arrived_pos + ch_offset(i))), VLOW, true); + error_flag := true; + end if; + end if; + end loop; + end loop; + end loop; + + if (stimuli_completed = true) then + -- wait enough time to make sure that a max length package can be propagated + wait for 20 us; + end if; + + if (registers_read = false) then + -- Signal from pUUT_CTRL + wait until registers_read = true; + end if; + + -- check print_start has stayed high + if fpm_print_start_rx'last_event < (now - 500 ns) then + log("Print Start last event : " & time'image(fpm_print_start_rx'last_event), VLOW, true); + error_flag := true; + end if; + + -- Report PD and FP counter from pulse generator + for i in 0 to CH_NUM - 1 loop + log("Channel CH" & integer'image(i) & " PD-in counter value : " & integer'image(pd_cnt(i)) & " ... ", VLOW, true); + log("Channel CH" & integer'image(i) & " FP-out counter value : " & integer'image(fp_cnt(i)) & " ... ", VLOW, true); + log("Channel CH" & integer'image(i) & " Detected Fire-Pulses : " & integer'image(loc_fp_cnt(i)) & " ... ", VLOW, true); + if (pd_cnt(i) /= (NUM_ITERATIONS) * 2 * 2) then -- fire_pulse_manager now has no registers beyond channel 0 + log("Channel CH" & integer'image(i) & " PD_cnt counter value Incorrect: ", VLOW, true); + error_flag := true; + end if; + if ((loc_fp_cnt(i) /= (NUM_ITERATIONS) * 2 * 2 * IMAGE_SIZE) or (fp_cnt(i) /= (NUM_ITERATIONS) * 2 * 2 * IMAGE_SIZE)) then + log("Channel CH" & integer'image(i) & " FP_cnt counter value Incorrect: ", VLOW, true); + error_flag := true; + end if; + end loop; + + wait until clk = '1' and clk'event; + + running <= false; + passed <= true after 100 ns; + wait; + + end process pTB_CTRL; + + pFAILED : process + begin + failed <= false; + while true loop + wait for 1 us; + if (error_flag = true) then + failed <= true; + end if; + end loop; + end process pFAILED; + + pREPORT_RESULT : process + begin + wait until failed = true or passed = true; + wait for 1 us; + log_separator_line(VLOW); + if (failed = true) then + log("FAILURE: test completed with errors.", VLOW); + elsif (passed = true) then + log("SUCCESS: test successfully completed.", VLOW); + end if; + log_separator_line(VLOW); + test_completed <= true; + end process pREPORT_RESULT; + + pUUT_CTRL : process + variable addr : std_logic_vector(31 downto 0) := (others => '0'); + variable data : std_logic_vector(31 downto 0) := (others => '0'); + + begin + sel_slave_DUT <= '0'; + sel_slave_TB_POFTX <= '0'; + rst_fp_cnt <= '0'; + configuring <= true; + + input_mode <= POF_INPUT; + + run_dw <= '0'; + + -- Initialize avalon mm interfaces + mm_m_init(avs_m, use_waitrequest => false); + + if (reset_n = '0') then + wait until reset_n = '1'; + wait for 100 ns; + wait until clk = '1' and clk'event; + end if; + + log("Driving external pulses ... ", VLOW, true); + ext_pulse_enable <= '1'; + wait for 20 us; + ext_pulse_enable <= '0'; + wait for 1 us; + wait until clk = '1' and clk'event; + -- signal to pOUT_CHECK_REGs to reset its own count + rst_fp_cnt <= '1'; + wait until clk = '1' and clk'event; + rst_fp_cnt <= '0'; + + log("Configuring POFTX ... ", VLOW, true); + sel_slave_TB_POFTX <= '1'; + -- enable the block + addr := std_logic_vector(to_unsigned(0, 32)); + data := X"0000_0021"; + mm_32b_write(addr, data, avs_s, avs_m); + + sel_slave_TB_POFTX <= '0'; + sel_slave_DUT <= '1'; + wait until clk = '1' and clk'event; + + log("Configuring FPM (DUT) ... ", VLOW, true); + + fpm_ctrl_config(avs_s, avs_m); + + fpm_ems_config(avs_s, avs_m); + + config_pg_l : for i in 0 to CH_NUM - 1 loop + + pulse_gen_config(i, ch_offset(i), DIV_RATIO, SUBPIX_PHASES, IMAGE_SIZE, avs_s, avs_m); + + end loop config_pg_l; + + log("Configuration completed.", VLOW, true); + configuring <= false; + + log_separator_line(VLOW); + log("POF input mode verification", VLOW, true); + log_separator_line(VLOW); + + fpm_input_config(input_mode, avs_s, avs_m); + + if (DRIVE_DROP_WATCH = true) then + drop_watch_config('1', "0001", 15, avs_s, avs_m); + end if; + + while stimuli_completed = false loop + wait until reprogram_offset = true or stimuli_completed = true; + if (stimuli_completed) then + exit; + end if; + + log("Reading counters ... ", VLOW, true); + -- Read PD and FP counter from pulse generator + for i in 0 to CH_NUM - 1 loop + fpm_reg_read(PG_CH_ID + i, work.pulse_generator_5_pkg.CSR_PD_COUNTER_ADDR, data, avs_s, avs_m); + pd_cnt(i) <= to_integer(unsigned(data)); + fpm_reg_read(PG_CH_ID + i, work.pulse_generator_5_pkg.CSR_FIRE_REQ_COUNTER_ADDR, data, avs_s, avs_m); + fp_cnt(i) <= to_integer(unsigned(data)); + wait until clk = '1' and clk'event; + log("CH-" & to_string(i) & ": pd_in_cnt = " & to_string(pd_cnt(i)) & ", fire_req_cnt = " & to_string(fp_cnt(i)) & ", detected fire-req-cnt = " & to_string(loc_fp_cnt(i)), VMEDIUM); + end loop; + + configuring <= true; + + -- Reprogram the input to EPD and repeat the same number of iterations + if (swathe_cnt = NUM_ITERATIONS) then + log_separator_line(VLOW); + log("EPD input mode verification", VLOW, true); + log_separator_line(VLOW); + + input_mode <= EPD_INPUT; + wait until clk = '1' and clk'event; + fpm_input_config(input_mode, avs_s, avs_m); + + if (DRIVE_DROP_WATCH = true) then + drop_watch_config('1', "0001", 15, avs_s, avs_m); + end if; + + run_dw <= '1'; + end if; + + log("Reprogramming offset ... ", VLOW, true); + config_of_l : for i in 0 to CH_NUM - 1 loop + ch_offset_config(i, ch_offset(i), avs_s, avs_m); + end loop; + configuring <= false; + end loop; + + log("Reading counters ... ", VLOW, true); + -- Read PD and FP counter from pulse generator + for i in 0 to CH_NUM - 1 loop + fpm_reg_read(PG_CH_ID + i, work.pulse_generator_5_pkg.CSR_PD_COUNTER_ADDR, data, avs_s, avs_m); + pd_cnt(i) <= to_integer(unsigned(data)); + fpm_reg_read(PG_CH_ID + i, work.pulse_generator_5_pkg.CSR_FIRE_REQ_COUNTER_ADDR, data, avs_s, avs_m); + fp_cnt(i) <= to_integer(unsigned(data)); + wait until clk = '1' and clk'event; + log("CH-" & to_string(i) & ": pd_in_cnt = " & to_string(pd_cnt(i)) & ", fire_req_cnt = " & to_string(fp_cnt(i)), VMEDIUM); + end loop; + -- As a check that init can be sent safely. Needs visual inspection of transcript and waveform + fpm_init(avs_s, avs_m); + + wait for 1 us; + fpm_init(avs_s, avs_m); + + wait for 1 us; + registers_read <= true; + + + wait; + end process pUUT_CTRL; + + clk_clk <= clk; + reset_reset_n <= reset_n; + + avs_s.mm_readdata <= avs_readdata(AVS_ADDR_DUT) when sel_slave_DUT = '1' else + avs_readdata(AVS_ADDR_TB_POFTX) when sel_slave_TB_POFTX = '1' else (others => '0'); + + avs_s.mm_readdatavalid <= '0'; + + avs_s.mm_waitrequest <= '0'; + + avs_address <= avs_m.mm_address(avs_address'range); + avs_write(AVS_ADDR_DUT) <= avs_m.mm_write and sel_slave_DUT; + avs_write(AVS_ADDR_TB_POFTX) <= avs_m.mm_write and sel_slave_TB_POFTX; + avs_writedata <= avs_m.mm_writedata; + avs_read(AVS_ADDR_DUT) <= avs_m.mm_read and sel_slave_DUT; + avs_read(AVS_ADDR_TB_POFTX) <= avs_m.mm_read and sel_slave_TB_POFTX; + + -- Emulator Avalon bus maapings + emul_s.mm_readdata <= emul_readdata; + emul_s.mm_readdatavalid <= '0'; + emul_s.mm_waitrequest <= '0'; + + emul_address <= emul_m.mm_address(emul_address'range); + emul_writedata <= emul_m.mm_writedata; + emul_write <= emul_m.mm_write; + emul_read <= emul_m.mm_read; + +end behav; + diff --git a/generic_ip/fire_pulse_manager/8/src/test/fire_pulse_manager_8_tb_pkg.vhd b/generic_ip/fire_pulse_manager/8/src/test/fire_pulse_manager_8_tb_pkg.vhd new file mode 100644 index 0000000..f772b45 --- /dev/null +++ b/generic_ip/fire_pulse_manager/8/src/test/fire_pulse_manager_8_tb_pkg.vhd @@ -0,0 +1,869 @@ +------------------------------------------------------------------------------- +-- Title : fire_pulse_manager_8_tb_pkg +-- Project : SMB +------------------------------------------------------------------------------- +-- File : fire_pulse_manager_8_tb_pkg.vhd +-- Author : Gianmarco Girau +-- Company : Global Inkjet Systems +-- Created : 2020-01-02 +-- Last update: 2021-01-06 +-- SVN ID : Git +-- Standard : VHDL'2008 +------------------------------------------------------------------------------- +-- Description: +-- Support package for the FPM testbench +------------------------------------------------------------------------------- + +--library std; +--use std.textio.all; + +library ieee; +use ieee.std_logic_1164.all; +use ieee.std_logic_textio.all; +use ieee.numeric_std.all; +use ieee.math_real.all; + +library work; +use work.fire_pulse_8_pkg.all; +use work.ems_1_pkg.all; +use work.fpm_ctrl_8_pkg.all; + +library OSVVM; +use OSVVM.RandomBasePkg.all; +use OSVVM.RandomPkg.all; + +library work; +use work.log_pkg.all; +use work.avalon_verify_pkg_2.all; +use work.enc_pd_emul_3_pkg.all; + +package fire_pulse_manager_8_tb_pkg is + + constant CLK_PERIOD : time := 10.0 ns; + constant CLK_FREQ : real := 100.0e6; + + constant CH_NUM : integer := 4; + constant BLK_NUM : natural := 6 + CH_NUM; + + constant ENC_NCO_WIDTH : positive := 32; + + -- Logging Verbosity Level + constant VERBOSITY_LEVEL : verb_level_t := VMEDIUM; + + type fpm_input_type_t is (POF_INPUT, EPD_INPUT, INTERNAL); + + ----------------------------------------------------------------------------- + -- FPM Configuration + ----------------------------------------------------------------------------- + + -- fpm_reg_write with addr defined as std_logic_vector + procedure fpm_reg_write( + blk_id : in natural range 0 to BLK_NUM-1; + addr : in std_logic_vector; + data : in std_logic_vector(31 downto 0); + signal mm_s : in mm_s_rec_t; + signal mm_m : out mm_m_rec_t); + + -- fpm_reg_write with addr defined as integer + procedure fpm_reg_write( + blk_id : in natural range 0 to BLK_NUM-1; + addr : in integer; + data : in std_logic_vector(31 downto 0); + signal mm_s : in mm_s_rec_t; + signal mm_m : out mm_m_rec_t); + + -- fpm_reg_read with addr defined as std_logic_vector + procedure fpm_reg_read( + blk_id : in natural range 0 to BLK_NUM-1; + addr : in std_logic_vector; + data : out std_logic_vector(31 downto 0); + signal mm_s : in mm_s_rec_t; + signal mm_m : out mm_m_rec_t); + + -- fpm_reg_read with addr defined as integer + procedure fpm_reg_read( + blk_id : in natural range 0 to BLK_NUM-1; + addr : in integer; + data : out std_logic_vector(31 downto 0); + signal mm_s : in mm_s_rec_t; + signal mm_m : out mm_m_rec_t); + + procedure fpm_ctrl_config( + signal mm_s : in mm_s_rec_t; + signal mm_m : out mm_m_rec_t); + + procedure ch_offset_config( + ch_id : in natural; + ch_offset : in natural; + signal mm_s : in mm_s_rec_t; + signal mm_m : out mm_m_rec_t); + + procedure ch_ctrl_config( + ch_id : in natural; + pixel_num : in natural; + signal mm_s : in mm_s_rec_t; + signal mm_m : out mm_m_rec_t); + + procedure pulse_gen_config( + ch_id : in natural; + ch_offset : in natural; + div_ratio : in real; + subpix_phases : in natural; + pixel_num : in natural; + signal mm_s : in mm_s_rec_t; + signal mm_m : out mm_m_rec_t); + + procedure fpm_init( + signal mm_s : in mm_s_rec_t; + signal mm_m : out mm_m_rec_t); + + procedure fpm_input_config( + input_type : in fpm_input_type_t; + signal mm_s : in mm_s_rec_t; + signal mm_m : out mm_m_rec_t); + + procedure fpm_ems_config( + signal mm_s : in mm_s_rec_t; + signal mm_m : out mm_m_rec_t); + + procedure drop_watch_config( + enable : in std_logic; + src : in std_logic_vector(3 downto 0); + pulse_witdth : in natural; + signal mm_s : in mm_s_rec_t; + signal mm_m : out mm_m_rec_t); + + ----------------------------------------------------------------------------- + -- ENC/PD Emulator Configuration + ----------------------------------------------------------------------------- + + type enc_phase_t is (SINGLE_PHASE, DUAL_PHASE); + type enc_edge_t is (RISING, FALLING, RISING_AND_FALLING); + type pd_edge_t is (RISING, FALLING, RISING_AND_FALLING); + subtype enc_freq_t is real range 0.0e3 to 10.0e6; + subtype pd_pulse_width_t is real range 0.0 to 1000.0; -- PD period in us + --subtype pd_period_t is real range 50.0 to 1.0e6; -- PD period in us + subtype pd_period_t is real range 0.5 to 1.0e6; -- PD period in us + + type enc_dir_t is (DIR_0, DIR_1); + + type emul_cfg_t is record + + enc_res : real; + enc_ppr : integer; + enc_phase : enc_phase_t; + enc_edge : enc_edge_t; + enc_dir : enc_dir_t; + pd_edge : pd_edge_t; + enc_freq : enc_freq_t; + pd_pulse_w : pd_pulse_width_t; + pd_period : pd_period_t; + enc_pulses : integer; + + end record emul_cfg_t; + + -- set abs-pos + procedure set_enc_abs_pos( + abs_pos : in std_logic_vector(39 downto 0); + signal mm_s_rec : in mm_s_rec_t; + signal mm_m_rec : out mm_m_rec_t); + + -- The ENC/PD emulator configuration is derived from the EMS + procedure apply_enc_pd_emul_cfg( + cfg : in emul_cfg_t; + init : in boolean := true; + run_pulses_mode : in boolean := false; + signal mm_s_rec : in mm_s_rec_t; + signal mm_m_rec : out mm_m_rec_t); + + -- Stop the ENC/PD emulator + procedure stop_enc_pd_emul( + signal mm_s_rec : in mm_s_rec_t; + signal mm_m_rec : out mm_m_rec_t); + + procedure check_max_pulses_done( + done : out boolean; + signal mm_s_rec : in mm_s_rec_t; + signal mm_m_rec : out mm_m_rec_t); + + -- Run a fix number of encoder pulses + procedure run_enc_pulses( + enc_freq : in enc_freq_t; + direction : in enc_dir_t; + double_ph_mode : in boolean := true; + num_pulses : in integer; + enc_ppr : in integer; + signal mm_s_rec : in mm_s_rec_t; + signal mm_m_rec : out mm_m_rec_t); + + -- Run PD pulses: either single pulse or periodic mode + procedure run_pd_pulses( + pulse_width : in pd_pulse_width_t; + pd_period : in pd_period_t; + single_pulse_mode : in boolean := false; + signal mm_s_rec : in mm_s_rec_t; + signal mm_m_rec : out mm_m_rec_t); + + ----------------------------------------------------------------------------- + -- Support functions + ----------------------------------------------------------------------------- + + -- generate the NCO increment corresponding to a given output frequency + function freq2NCO_inc( + f_out : real; f_clk : real) return std_logic_vector; + +end fire_pulse_manager_8_tb_pkg; + +package body fire_pulse_manager_8_tb_pkg is + + ----------------------------------------------------------------------------- + -- FPM Configuration + ----------------------------------------------------------------------------- + + -- fpm_reg_write with addr defined as std_logic_vector + procedure fpm_reg_write( + blk_id : in natural range 0 to BLK_NUM-1; + addr : in std_logic_vector; + data : in std_logic_vector(31 downto 0); + signal mm_s : in mm_s_rec_t; + signal mm_m : out mm_m_rec_t) is + + variable address : std_logic_vector(31 downto 0); + + begin + + address := std_logic_vector(to_unsigned(blk_id * BLK_SIZE + to_integer(unsigned(addr)), 32)); + mm_32b_write(address, data, mm_s, mm_m); + + end procedure fpm_reg_write; + + -- fpm_reg_write with addr defined as integer + procedure fpm_reg_write( + blk_id : in natural range 0 to BLK_NUM-1; + addr : in integer; + data : in std_logic_vector(31 downto 0); + signal mm_s : in mm_s_rec_t; + signal mm_m : out mm_m_rec_t) is + + variable address : std_logic_vector(31 downto 0); + + begin + + address := std_logic_vector(to_unsigned((blk_id * BLK_SIZE) + addr, 32)); + mm_32b_write(address, data, mm_s, mm_m); + + end procedure fpm_reg_write; + + -- fpm_reg_read with addr defined as std_logic_vector + procedure fpm_reg_read( + blk_id : in natural range 0 to BLK_NUM-1; + addr : in std_logic_vector; + data : out std_logic_vector(31 downto 0); + signal mm_s : in mm_s_rec_t; + signal mm_m : out mm_m_rec_t) is + + variable address : std_logic_vector(31 downto 0); + + begin + + address := std_logic_vector(to_unsigned(blk_id * BLK_SIZE + to_integer(unsigned(addr)), 32)); + mm_32b_read(address, data, mm_s, mm_m); + + end procedure fpm_reg_read; + + -- fpm_reg_read with addr defined as std_logic_vector + procedure fpm_reg_read( + blk_id : in natural range 0 to BLK_NUM-1; + addr : in integer; + data : out std_logic_vector(31 downto 0); + signal mm_s : in mm_s_rec_t; + signal mm_m : out mm_m_rec_t) is + + variable address : std_logic_vector(31 downto 0); + + begin + + address := std_logic_vector(to_unsigned((blk_id * BLK_SIZE) + addr, 32)); + mm_32b_read(address, data, mm_s, mm_m); + + end procedure fpm_reg_read; + + procedure fpm_ctrl_config( + signal mm_s : in mm_s_rec_t; + signal mm_m : out mm_m_rec_t) is + + variable data : std_logic_vector(31 downto 0); + + begin + + log("Configuring FPM Controller ... ", VMEDIUM, true); + -- Enable the POF-Rx + data := X"0000_0001"; + fpm_reg_write(FP_CTRL_ID, CSR_POF_RECEIVER_CONTROL_ADDR_INT, data, mm_s, mm_m); + + fpm_reg_read(FP_CTRL_ID, CSR_SIGNAL_SELECTION_ADDR_INT, data, mm_s, mm_m); + + -- Select the input source + data(2 downto 0) := b"001"; + fpm_reg_write(FP_CTRL_ID, CSR_SIGNAL_SELECTION_ADDR_INT, data, mm_s, mm_m); + + end procedure fpm_ctrl_config; + + procedure ch_offset_config( + ch_id : in natural; + ch_offset : in natural; + signal mm_s : in mm_s_rec_t; + signal mm_m : out mm_m_rec_t) is + + variable data : std_logic_vector(31 downto 0); + + begin + + -- Disable/Re-enable first the whole pulse_generator + data := std_logic_vector(to_unsigned(ch_offset, 32)); + fpm_reg_write(PG_CH_ID + ch_id, work.pulse_generator_6_pkg.CSR_PD_OFFSET_DIR_0_ADDR, data, mm_s, mm_m); + fpm_reg_write(PG_CH_ID + ch_id, work.pulse_generator_6_pkg.CSR_PD_OFFSET_DIR_1_ADDR, data, mm_s, mm_m); + + log("CH-" & to_string(ch_id) & ": PD offset configured to " & to_string(ch_offset) & ".", VMEDIUM); + + end procedure ch_offset_config; + + procedure ch_ctrl_config( + ch_id : in natural; + pixel_num : in natural; + signal mm_s : in mm_s_rec_t; + signal mm_m : out mm_m_rec_t) is + + variable data : std_logic_vector(31 downto 0); + variable ram_idx : natural; + variable ram_offset : natural; + + begin + + ram_offset := to_integer(unsigned(work.pulse_generator_6_pkg.SEQ_GENERIC_SEQUENCER_19_CHANNEL_ADDR)); + ram_idx := 0; + + -- Issue first an image on DIR-0, then on DIR-1 + -- Reset the vector output value + data := X"30000000"; + fpm_reg_write(PG_CH_ID + ch_id, ram_offset + ram_idx, data, mm_s, mm_m); + ram_idx := ram_idx + 1; + -- Enable Trigger Mask (All the triggers) + data := X"1000000F"; + fpm_reg_write(PG_CH_ID + ch_id, ram_offset + ram_idx, data, mm_s, mm_m); + ram_idx := ram_idx + 1; + -- Wait for a single PD event + data := X"20000001"; + fpm_reg_write(PG_CH_ID + ch_id, ram_offset + ram_idx, data, mm_s, mm_m); + ram_idx := ram_idx + 1; + -- Issue a request to generate 'pixel_num' fire requests + data := X"30" & std_logic_vector(to_unsigned(pixel_num, 16)) & X"24"; + fpm_reg_write(PG_CH_ID + ch_id, ram_offset + ram_idx, data, mm_s, mm_m); + ram_idx := ram_idx + 1; + data := X"30" & std_logic_vector(to_unsigned(pixel_num, 16)) & X"00"; + fpm_reg_write(PG_CH_ID + ch_id, ram_offset + ram_idx, data, mm_s, mm_m); + ram_idx := ram_idx + 1; + -- wait until the end of the image + data := X"23000001"; + fpm_reg_write(PG_CH_ID + ch_id, ram_offset + ram_idx, data, mm_s, mm_m); + ram_idx := ram_idx + 1; + -- Switch to DIR-1 + data := X"30000001"; + fpm_reg_write(PG_CH_ID + ch_id, ram_offset + ram_idx, data, mm_s, mm_m); + ram_idx := ram_idx + 1; + -- Wait for a single PD event + data := X"20000001"; + fpm_reg_write(PG_CH_ID + ch_id, ram_offset + ram_idx, data, mm_s, mm_m); + ram_idx := ram_idx + 1; + -- Issue a request to generate 'pixel_num' fire requests + data := X"30" & std_logic_vector(to_unsigned(pixel_num, 16)) & X"25"; + fpm_reg_write(PG_CH_ID + ch_id, ram_offset + ram_idx, data, mm_s, mm_m); + ram_idx := ram_idx + 1; + data := X"30" & std_logic_vector(to_unsigned(pixel_num, 16)) & X"01"; + fpm_reg_write(PG_CH_ID + ch_id, ram_offset + ram_idx, data, mm_s, mm_m); + ram_idx := ram_idx + 1; + -- wait until the end of the image + data := X"23000001"; + fpm_reg_write(PG_CH_ID + ch_id, ram_offset + ram_idx, data, mm_s, mm_m); + ram_idx := ram_idx + 1; + -- Jump to DIR-0 + data := X"C0000000"; + fpm_reg_write(PG_CH_ID + ch_id, ram_offset + ram_idx, data, mm_s, mm_m); + ram_idx := ram_idx + 1; + + end procedure ch_ctrl_config; + + procedure pulse_gen_config( + ch_id : in natural; + ch_offset : in natural; + div_ratio : in real; + subpix_phases : in natural; + pixel_num : in natural; + signal mm_s : in mm_s_rec_t; + signal mm_m : out mm_m_rec_t) is + + variable data : std_logic_vector(31 downto 0); + variable ratio_int : integer; + variable ratio_slv : std_logic_vector(33 downto 0); + + begin + + log("Configuring Channel " & to_string(ch_id) & " ... ", VMEDIUM, true); + + -- Disable/Re-enable first the whole pulse_generator + data := (others => '0'); + fpm_reg_write(PG_CH_ID + ch_id, work.pulse_generator_6_pkg.CSR_PULSE_GEN_CONTROL_W_ADDR, data, mm_s, mm_m); + data := (0 => '1', 16 => '1', others => '0'); + fpm_reg_write(PG_CH_ID + ch_id, work.pulse_generator_6_pkg.CSR_PULSE_GEN_CONTROL_W_ADDR, data, mm_s, mm_m); + + -- Disable/Re-enable the Channel Controller sequencer + data := (others => '0'); + fpm_reg_write(PG_CH_ID + ch_id, to_integer(unsigned(work.pulse_generator_6_pkg.CSR_GENERIC_SEQUENCER_19_CHANNEL_ADDR)) + 3, data, mm_s, mm_m); + data := (0 => '1', others => '0'); + fpm_reg_write(PG_CH_ID + ch_id, to_integer(unsigned(work.pulse_generator_6_pkg.CSR_GENERIC_SEQUENCER_19_CHANNEL_ADDR)) + 3, data, mm_s, mm_m); + + -- Set the number of sub-pixel phases + data := std_logic_vector(to_unsigned(subpix_phases, 32)); + fpm_reg_write(PG_CH_ID + ch_id, work.pulse_generator_6_pkg.CSR_SUBPIXEL_PHASE_NUM_ADDR, data, mm_s, mm_m); + + -- set the division ratio + ratio_int := integer((div_ratio / real(subpix_phases)) * real(2 ** 24)); + ratio_slv := std_logic_vector(to_unsigned(ratio_int, 34)); + -- Set the integer part of the div-ratio + data(31 downto 10) := (others => '0'); + data(9 downto 0) := ratio_slv(33 downto 24); + fpm_reg_write(PG_CH_ID + ch_id, work.pulse_generator_6_pkg.CSR_DIVIDER_RATIO_INT_ADDR, data, mm_s, mm_m); + data(31 downto 24) := (others => '0'); + data(23 downto 0) := ratio_slv(23 downto 0); + fpm_reg_write(PG_CH_ID + ch_id, work.pulse_generator_6_pkg.CSR_DIVIDER_RATIO_FRACTION_ADDR, data, mm_s, mm_m); + -- Disable/Enable the fractional divider + data := (others => '0'); + fpm_reg_write(PG_CH_ID + ch_id, work.pulse_generator_6_pkg.CSR_FRACTIONAL_DIVIDER_CONTROL_ADDR, data, mm_s, mm_m); + data := (0 => '1', others => '0'); + fpm_reg_write(PG_CH_ID + ch_id, work.pulse_generator_6_pkg.CSR_FRACTIONAL_DIVIDER_CONTROL_ADDR, data, mm_s, mm_m); + + -- configure the channel offset + ch_offset_config(ch_id, ch_offset, mm_s, mm_m); + + -- Configure the sequencer RAM + ch_ctrl_config(ch_id, pixel_num, mm_s, mm_m); + + -- Restart the sequencer + data := (others => '0'); + fpm_reg_write(PG_CH_ID + ch_id, work.pulse_generator_6_pkg.CSR_CHANNEL_CONTROLLER_CONTROL_W_ADDR, data, mm_s, mm_m); + data := (0 => '1', others => '0'); + fpm_reg_write(PG_CH_ID + ch_id, work.pulse_generator_6_pkg.CSR_CHANNEL_CONTROLLER_CONTROL_W_ADDR, data, mm_s, mm_m); + + end procedure pulse_gen_config; + + + procedure fpm_init( + signal mm_s : in mm_s_rec_t; + signal mm_m : out mm_m_rec_t) is + + variable data : std_logic_vector(31 downto 0) := (others => '0'); + + begin + + -- Set the init_start bit + data(0) := '1'; + fpm_reg_write(FP_CTRL_ID, work.fpm_ctrl_8_pkg.CSR_FPM_INIT_START_ADDR, data, mm_s, mm_m); + + wait for 1 us; + -- ReSet the init_start bit + data(0) := '0'; + fpm_reg_write(FP_CTRL_ID, work.fpm_ctrl_8_pkg.CSR_FPM_INIT_START_ADDR, data, mm_s, mm_m); + + for i in 1 to 10 loop + -- Check if init is complete + fpm_reg_read(FP_CTRL_ID, work.fpm_ctrl_8_pkg.CSR_FPM_INIT_DONE_ADDR, data, mm_s, mm_m); + if data(0) = '1' then + exit; + else + wait for 300 ns; + end if; + + end loop; + + if data(0) = '1' then + log("FPM INIT completed", VMEDIUM, true); + else + log("ERROR: FPM INIT never completed", V_LOW, true); + wait for 2 us; + end if; + + end procedure fpm_init; + + procedure fpm_input_config( + input_type : in fpm_input_type_t; + signal mm_s : in mm_s_rec_t; + signal mm_m : out mm_m_rec_t) is + + variable data : std_logic_vector(31 downto 0); + + begin + + + + if (input_type = POF_INPUT) then + + fpm_reg_read(FP_CTRL_ID, CSR_SIGNAL_SELECTION_ADDR_INT, data, mm_s, mm_m); + + data(2 downto 0) := b"001"; + fpm_reg_write(FP_CTRL_ID, CSR_SIGNAL_SELECTION_ADDR_INT, data, mm_s, mm_m); + log("FPM input set to POF. ", VLOW, true); + + elsif (input_type = EPD_INPUT) then + + data(2 downto 0) := b"101"; + fpm_reg_write(FP_CTRL_ID, CSR_SIGNAL_SELECTION_ADDR_INT, data, mm_s, mm_m); + log("FPM input set to EPD. ", VLOW, true); + + end if; + + end procedure fpm_input_config; + + + procedure fpm_ems_config( + signal mm_s : in mm_s_rec_t; + signal mm_m : out mm_m_rec_t) is + + variable data : std_logic_vector(31 downto 0); + + begin + + log("Configuring EMS ... ", VMEDIUM, true); + + -- EMS software init + fpm_reg_write(EMS_BLK_ID, work.ems_1_pkg.CSR_EMS_ENABLE_ADDR, 32x"1", mm_s, mm_m); + + -- disable the EMS during the configuration + fpm_reg_write(EMS_BLK_ID, work.ems_1_pkg.CSR_EMS_ENABLE_ADDR, 32x"0", mm_s, mm_m); + + -- apply EMS config + fpm_reg_write(EMS_BLK_ID, work.ems_1_pkg.CSR_EMS_CONFIG_ADDR, 32x"3E0", mm_s, mm_m); + + -- enable the EMS + fpm_reg_write(EMS_BLK_ID, work.ems_1_pkg.CSR_EMS_ENABLE_ADDR, 32x"E", mm_s, mm_m); + + end procedure fpm_ems_config; + + procedure drop_watch_config( + enable : in std_logic; + src : in std_logic_vector(3 downto 0); + pulse_witdth : in natural; + signal mm_s : in mm_s_rec_t; + signal mm_m : out mm_m_rec_t) is + + variable data : std_logic_vector(31 downto 0); + + begin + + -- configure the drop-watch + data := std_logic_vector(to_unsigned(pulse_witdth, 16)) & X"000" & src; + fpm_reg_write(FP_CTRL_ID, work.fpm_ctrl_8_pkg.CSR_DROP_WATCH_CONFIG_ADDR_INT, data, mm_s, mm_m); + + -- Enable/disable the drop-watch + fpm_reg_read(FP_CTRL_ID, work.fpm_ctrl_8_pkg.CSR_SIGNAL_SELECTION_ADDR_INT, data, mm_s, mm_m); + data(3) := enable; + fpm_reg_write(FP_CTRL_ID, work.fpm_ctrl_8_pkg.CSR_SIGNAL_SELECTION_ADDR_INT, data, mm_s, mm_m); + + if (enable = '1') then + log("Drop-Watch output enable on channel " & to_string(to_integer(unsigned(src))) & ".", VMEDIUM, true); + else + log("Drop-Watch output disabled.", VMEDIUM, true); + end if; + + end procedure drop_watch_config; + + ----------------------------------------------------------------------------- + -- ENC/PD Emulator Configuration + ----------------------------------------------------------------------------- + + procedure set_enc_abs_pos( + abs_pos : in std_logic_vector(39 downto 0); + signal mm_s_rec : in mm_s_rec_t; + signal mm_m_rec : out mm_m_rec_t) is + + variable addr : std_logic_vector(31 downto 0) := (others => '0'); + variable data : std_logic_vector(31 downto 0) := (others => '0'); + + begin + + -- set the value for MSBs + addr := std_logic_vector(resize(unsigned(CSR_POS_INIT_MSB_ADDR), 32)); + mm_32b_write(addr, 24x"0" & abs_pos(39 downto 32), mm_s_rec, mm_m_rec); + -- set the value for LSBs + addr := std_logic_vector(resize(unsigned(CSR_POS_INIT_LSB_ADDR), 32)); + mm_32b_write(addr, abs_pos(31 downto 0), mm_s_rec, mm_m_rec); + -- read back the encoder configuration, then apply the set_abs_pos control + -- bit + addr := std_logic_vector(resize(unsigned(CSR_ENC_CTRL_W_ADDR), 32)); + mm_32b_read(addr, data, mm_s_rec, mm_m_rec); + data(3) := '1'; + mm_32b_write(addr, data, mm_s_rec, mm_m_rec); + + log("Encoder/PD emulator abs-pos preset to " & to_string(to_integer(signed(abs_pos))) & ".", VMEDIUM); + + + end procedure set_enc_abs_pos; + + procedure apply_enc_pd_emul_cfg( + cfg : in emul_cfg_t; + init : in boolean := true; + run_pulses_mode : in boolean := false; + signal mm_s_rec : in mm_s_rec_t; + signal mm_m_rec : out mm_m_rec_t) is + + variable addr : std_logic_vector(31 downto 0) := (others => '0'); + variable data : std_logic_vector(31 downto 0) := (others => '0'); + variable data_check : std_logic_vector(31 downto 0) := (others => '0'); + -- + variable pd_low_period : real := 0.0; -- PD low period (ns) + variable pd_high_period : real := 0.0; -- PD high period (ns) + + begin + + -- Set the NCO inc: output freq + addr := std_logic_vector(resize(unsigned(CSR_ENC_NCO_INC_ADDR), 32)); + data := freq2NCO_inc(real(cfg.enc_freq), CLK_FREQ); + mm_32b_write(addr, data, mm_s_rec, mm_m_rec); + + -- set the max pulses register + addr := std_logic_vector(resize(unsigned(CSR_ENC_PULSE_NUM_ADDR), 32)); + data := std_logic_vector(to_unsigned(cfg.enc_pulses, 32)); + mm_32b_write(addr, data, mm_s_rec, mm_m_rec); + + -- set the zero-phase ppr number + addr := std_logic_vector(resize(unsigned(CSR_ENC_ZP_PPR_ADDR), 32)); + data := std_logic_vector(to_unsigned(cfg.enc_ppr, 32)); + mm_32b_write(addr, data, mm_s_rec, mm_m_rec); + + -- Enable only the necessary outputs: + if (cfg.enc_phase = DUAL_PHASE) then + data := 32x"FF"; + else + data := 32x"BB"; + end if; + addr := std_logic_vector(resize(unsigned(CSR_OUT_ENABLE_ADDR), 32)); + mm_32b_write(addr, data, mm_s_rec, mm_m_rec); + + addr := std_logic_vector(resize(unsigned(CSR_ENC_CTRL_W_ADDR), 32)); + if (init = true) then + mm_32b_write(addr, 32x"2", mm_s_rec, mm_m_rec); + end if; + + data := (others => '0'); + if (run_pulses_mode = true) then + data(4) := '1'; + end if; + if (cfg.enc_dir = DIR_0) then + data(2) := '0'; + else + data(2) := '1'; + end if; + + -- enable the encoder + data(0) := '1'; + mm_32b_write(addr, data, mm_s_rec, mm_m_rec); + + log("Encoder/PD emulator enabled.", VMEDIUM); + + end procedure apply_enc_pd_emul_cfg; + + -- Stop the ENC/PD emulator + procedure stop_enc_pd_emul( + signal mm_s_rec : in mm_s_rec_t; + signal mm_m_rec : out mm_m_rec_t) is + + variable addr : std_logic_vector(31 downto 0) := (others => '0'); + variable data : std_logic_vector(31 downto 0) := (others => '0'); + + begin + + -- Disable PD emulation + addr := std_logic_vector(resize(unsigned(CSR_PD_CTRL_ADDR), 32)); + mm_32b_read(addr, data, mm_s_rec, mm_m_rec); + data(0) := '0'; + mm_32b_write(addr, data, mm_s_rec, mm_m_rec); + + -- Disable Enc emulation + addr := std_logic_vector(resize(unsigned(CSR_ENC_CTRL_W_ADDR), 32)); + mm_32b_read(addr, data, mm_s_rec, mm_m_rec); + data(0) := '0'; + mm_32b_write(addr, data, mm_s_rec, mm_m_rec); + + end procedure stop_enc_pd_emul; + + -- Check whether the generation of a fixed number of encoder pulses has completed + procedure check_max_pulses_done( + done : out boolean; + signal mm_s_rec : in mm_s_rec_t; + signal mm_m_rec : out mm_m_rec_t) is + + variable addr : std_logic_vector(31 downto 0) := (others => '0'); + variable data : std_logic_vector(31 downto 0) := (others => '0'); + + begin + + addr := std_logic_vector(resize(unsigned(CSR_ENC_CTRL_R_ADDR), 32)); + mm_32b_read(addr, data, mm_s_rec, mm_m_rec); + + if (data(6) = '1') then + done := true; + else + done := false; + end if; + + end procedure check_max_pulses_done; + + -- Run a fix number of encoder pulses + procedure run_enc_pulses( + enc_freq : in enc_freq_t; + direction : in enc_dir_t; + double_ph_mode : in boolean := true; + num_pulses : in integer; + enc_ppr : in integer; + signal mm_s_rec : in mm_s_rec_t; + signal mm_m_rec : out mm_m_rec_t) is + + variable addr : std_logic_vector(31 downto 0) := (others => '0'); + variable data : std_logic_vector(31 downto 0) := (others => '0'); + variable data_check : std_logic_vector(31 downto 0) := (others => '0'); + + begin + + -- Set the NCO inc: output freq + addr := std_logic_vector(resize(unsigned(CSR_ENC_NCO_INC_ADDR), 32)); + data := freq2NCO_inc(real(enc_freq), CLK_FREQ); + mm_32b_write(addr, data, mm_s_rec, mm_m_rec); + + -- set the max pulses register + addr := std_logic_vector(resize(unsigned(CSR_ENC_PULSE_NUM_ADDR), 32)); + data := std_logic_vector(to_unsigned(num_pulses, 32)); + mm_32b_write(addr, data, mm_s_rec, mm_m_rec); + + -- set the zero-phase ppr number + addr := std_logic_vector(resize(unsigned(CSR_ENC_ZP_PPR_ADDR), 32)); + data := std_logic_vector(to_unsigned(enc_ppr, 32)); + mm_32b_write(addr, data, mm_s_rec, mm_m_rec); + + -- Enable only the necessary outputs: + if (double_ph_mode = true) then + data := 32x"FF"; + else + data := 32x"BB"; + end if; + addr := std_logic_vector(resize(unsigned(CSR_OUT_ENABLE_ADDR), 32)); + mm_32b_write(addr, data, mm_s_rec, mm_m_rec); + + addr := std_logic_vector(resize(unsigned(CSR_ENC_CTRL_W_ADDR), 32)); + data := (4 => '1', 5 => '1', others => '0'); + if (direction = DIR_0) then + data(2) := '0'; + else + data(2) := '1'; + end if; + + -- enable the encoder + data(0) := '1'; + mm_32b_write(addr, data, mm_s_rec, mm_m_rec); + + --log("Running encoder pulses ... ", VMEDIUM); + + end procedure run_enc_pulses; + + -- Run PD pulses: either single pulse or periodic mode + procedure run_pd_pulses( + pulse_width : in pd_pulse_width_t; + pd_period : in pd_period_t; + single_pulse_mode : in boolean := false; + signal mm_s_rec : in mm_s_rec_t; + signal mm_m_rec : out mm_m_rec_t) is + + variable addr : std_logic_vector(31 downto 0) := (others => '0'); + variable data : std_logic_vector(31 downto 0) := (others => '0'); + variable data_check : std_logic_vector(31 downto 0) := (others => '0'); + variable tmp_val : integer; + variable idx : integer; + variable loop_idx : integer; + + begin + + -- set the pulse width + addr := std_logic_vector(resize(unsigned(CSR_PD_PULSE_WIDTH_ADDR), 32)); + data := std_logic_vector(to_unsigned(integer(pulse_width * 100.0), 32)); + mm_32b_write(addr, data, mm_s_rec, mm_m_rec); + + -- No need to use the sequerncer for a single pulse + if (single_pulse_mode = true) then + addr := std_logic_vector(resize(unsigned(CSR_PD_CTRL_ADDR), 32)); + mm_32b_write(addr, 32x"3", mm_s_rec, mm_m_rec); + log("Issued single PD pulse. ", VMEDIUM); + return; + end if; + + -- Use the sequencer to generate periodic pulses (here the periodicity is + -- in time): First program the sequencer RAM with instructions to generate + -- pulses with the specified periodicity, then enable the sequencer, + -- finally trigger the start of the procedure: + + -- Write in the Emulator sequencer a simple procedure to issue PD pulses + addr := std_logic_vector(resize(unsigned(SEQ_GENERIC_SEQUENCER_19_ADDR)+0, 32)); + mm_32b_write(addr, X"100000FF", mm_s_rec, mm_m_rec); -- Enable triggers + addr := std_logic_vector(resize(unsigned(SEQ_GENERIC_SEQUENCER_19_ADDR)+1, 32)); + mm_32b_write(addr, X"30000000", mm_s_rec, mm_m_rec); -- All the outputs to zero + idx := 2; + loop_idx := idx; + if(pd_period >= 1.0) then + -- add a first trigger-wait instruction for 1-us pulses + addr := std_logic_vector(resize(unsigned(SEQ_GENERIC_SEQUENCER_19_ADDR)+idx, 32)); + tmp_val := integer(pd_period); + data := X"21000" & std_logic_vector(to_unsigned(tmp_val, 12)); + mm_32b_write(addr, data, mm_s_rec, mm_m_rec); -- trig_wait (us pulses) + idx := idx + 1; + end if; + -- add a second trigger on single clock cycle events + addr := std_logic_vector(resize(unsigned(SEQ_GENERIC_SEQUENCER_19_ADDR)+idx, 32)); + tmp_val := integer((pd_period-floor(pd_period))*100.0); + data := X"20000" & std_logic_vector(to_unsigned(tmp_val, 12)); + mm_32b_write(addr, data, mm_s_rec, mm_m_rec); -- trig_wait (clk pulses) + idx := idx + 1; + -- issue the PD pulse + addr := std_logic_vector(resize(unsigned(SEQ_GENERIC_SEQUENCER_19_ADDR)+idx, 32)); + mm_32b_write(addr, X"31000001", mm_s_rec, mm_m_rec); -- All the outputs to zero + idx := idx + 1; + -- Jump to the beginning of the loop + addr := std_logic_vector(resize(unsigned(SEQ_GENERIC_SEQUENCER_19_ADDR)+idx, 32)); + mm_32b_write(addr, X"31000001", mm_s_rec, mm_m_rec); -- All the outputs to zero + + -- Enable the sequencer + addr := std_logic_vector(resize(unsigned(SEQ_GENERIC_SEQUENCER_19_ADDR)+idx, 32)); + mm_32b_write(addr, 32x"1", mm_s_rec, mm_m_rec); -- All the outputs to zero + + -- issue a start-request to the sequencer + addr := std_logic_vector(resize(unsigned(CSR_SEQ_CTRL_ADDR), 32)); + data(0) := '1'; -- start-request bit + data(24 downto 16) := 9x"0"; -- EAM sequence start-address + mm_32b_write(addr, 32x"1", mm_s_rec, mm_m_rec); + + log("Running PD pulses ... ", VMEDIUM); + + end procedure run_pd_pulses; + + ----------------------------------------------------------------------------- + -- Support functions + ----------------------------------------------------------------------------- + + -- generate the NCO increment corresponding to a given output frequency + function freq2NCO_inc( + f_out : real; f_clk : real) return std_logic_vector is + variable nco_inc : std_logic_vector(ENC_NCO_WIDTH - 1 downto 0); + + begin + nco_inc := std_logic_vector(to_unsigned(integer((f_out / f_clk) * (2.0 ** ENC_NCO_WIDTH)), ENC_NCO_WIDTH)); + return nco_inc; + + end function freq2NCO_inc; + +end fire_pulse_manager_8_tb_pkg; diff --git a/generic_ip/fire_pulse_manager/8/src/test/led_tb.vhd b/generic_ip/fire_pulse_manager/8/src/test/led_tb.vhd new file mode 100644 index 0000000..36542cb --- /dev/null +++ b/generic_ip/fire_pulse_manager/8/src/test/led_tb.vhd @@ -0,0 +1,633 @@ +------------------------------------------------------------------------------- +-- Title : led_tb +-- Project : FPM +------------------------------------------------------------------------------- +-- File : led_tb.vhd +-- Author : GMG +-- Company : Global Inkjet Systems +-- Created : 2018-06-12 +-- Last update: 2020-01-20 +-- SVN ID : Git +-- Standard : VHDL'2008 +------------------------------------------------------------------------------- +-- Description: +-- Testbench for the FPM LED generator +------------------------------------------------------------------------------- + +library ieee; +use ieee.std_logic_1164.all; +use ieee.numeric_std.all; + +library work; +use work.log_pkg.all; + +entity led_tb is + -- .. +end entity led_tb; + +architecture behav of led_tb is + + constant CLK_PERIOD : time := 10 ns; + + constant CLK_FREQ : real := 100.0e6; -- target clock frequency + + -- Logging Verbosity Level + constant VERBOSITY_LEVEL : verb_level_t := VMEDIUM; + + constant MAX_SIM_TIME : time := 50.0 ms; -- Maximum simulation time + + constant MAX_PERIOD_MS : natural := 5; + constant GREEN_PERIOD_MS : natural := 2; + + constant RUN_ENC_TEST : boolean := true; + constant RUN_PD_TEST : boolean := true; + constant RUN_POF_TEST : boolean := true; + + + signal reset_n : std_logic := '0'; + signal clk : std_logic := '0'; + -- + signal init : std_logic; + signal pd : std_logic; + signal enc_p1 : std_logic; + signal enc_p2 : std_logic; + signal pof : std_logic; + signal all_ok : std_logic; + signal led_pd_g : std_logic; + signal led_pd_y : std_logic; + signal led_pd_r : std_logic; + signal led_enc_p1_g : std_logic; + signal led_enc_p1_y : std_logic; + signal led_enc_p1_r : std_logic; + signal led_enc_p2_g : std_logic; + signal led_enc_p2_y : std_logic; + signal led_enc_p2_r : std_logic; + signal led_pof_g : std_logic; + signal led_pof_y : std_logic; + signal led_pof_r : std_logic; + + -- TB specific signals + signal setup : boolean; + signal running : boolean; + signal passed : boolean := false; + signal failed : boolean := false; + signal test_timeout : boolean := false; + signal test_completed : boolean := false; + + signal error_flag : boolean; + +begin -- architecture behav + + clk <= not clk after 0.5*CLK_PERIOD; + + ----------------------------------------------------------------------------- + -- LED Generator (UUT) + ----------------------------------------------------------------------------- + + iUUT: entity work.seb_epd_led_gen_8 + generic map ( + MAX_PERIOD_MS => MAX_PERIOD_MS, + GREEN_PERIOD_MS => GREEN_PERIOD_MS) + port map ( + reset_n => reset_n, + clk => clk, + init => init, + pd => pd, + enc_p1 => enc_p1, + enc_p2 => enc_p2, + pof => pof, + all_ok => all_ok, + led_pd_g => led_pd_g, + led_pd_y => led_pd_y, + led_pd_r => led_pd_r, + led_enc_p1_g => led_enc_p1_g, + led_enc_p1_y => led_enc_p1_y, + led_enc_p1_r => led_enc_p1_r, + led_enc_p2_g => led_enc_p2_g, + led_enc_p2_y => led_enc_p2_y, + led_enc_p2_r => led_enc_p2_r, + led_pof_g => led_pof_g, + led_pof_y => led_pof_y, + led_pof_r => led_pof_r); + + + ----------------------------------------------------------------------------- + -- Testbench Logic + ----------------------------------------------------------------------------- + + pTEST_PROC : process + + begin + + --------------------------------------------------------------------------- + -- Initialize & Configure + --------------------------------------------------------------------------- + + reset_n <= '0'; + + init <= '0'; + + setup <= false; + + running <= false; + error_flag <= false; + + --Set the verbosity level for logging + set_log_verbosity(VERBOSITY_LEVEL); + + pd <= '0'; + enc_p1 <= '0'; + enc_p2 <= '0'; + pof <= '0'; + all_ok <= '0'; + + wait for 100 ns; + reset_n <= '1'; + + wait for 100 ns; + wait until clk = '1' and clk'event; + all_ok <= '1'; + + -- Nothing really to do here + setup <= true; + + --------------------------------------------------------------------------- + -- Running + --------------------------------------------------------------------------- + + running <= true; + log_separator_line(VLOW); + log("FPM (SEB-EPD) LEDs verification:", VLOW); + log_separator_line(VLOW); + + wait for 0.5 ms; + + --------------------------------------------------------------------------- + -- POF LED + --------------------------------------------------------------------------- + + if(RUN_POF_TEST = true) then + + log_separator_line(VLOW); + log("Testing POF LED:", VLOW); + wait for 5 us; + + if(led_pof_r /= '0') then + log("ERROR: POF Red LED must be LOW.", VLOW); + error_flag <= true; + end if; + if(led_pof_y /= '0') then + log("ERROR: POF Yellow LED must be LOW.", VLOW); + error_flag <= true; + end if; + if(led_pof_g /= '0') then + log("ERROR: POF Green LED must be LOW.", VLOW); + error_flag <= true; + end if; + + wait for 5 us; + wait until clk = '1' and clk'event; + pof <= not pof; + wait until clk = '1' and clk'event; + pof <= not pof; + + wait for 100 ns; + if(led_pof_g /= '1') then + log("ERROR: POF Green LED must be HIGH.", VLOW); + error_flag <= true; + end if; + if(led_pof_y /= '0') then + log("ERROR: POF Yellow LED must be LOW.", VLOW); + error_flag <= true; + end if; + + wait for 3 ms; + if(led_pof_g /= '0') then + log("ERROR: POF Green LED must be LOW.", VLOW); + error_flag <= true; + end if; + if(led_pof_y /= '0') then + log("ERROR: POF Yellow LED must be LOW.", VLOW); + error_flag <= true; + end if; + + wait for 3 ms; + if(led_pof_g /= '0') then + log("ERROR: POF Green LED must be LOW.", VLOW); + error_flag <= true; + end if; + if(led_pof_y /= '1') then + log("ERROR: POF Yellow LED must be HIGH.", VLOW); + error_flag <= true; + end if; + + wait for 5 us; + wait until clk = '1' and clk'event; + pof <= not pof; + wait until clk = '1' and clk'event; + pof <= not pof; + + wait for 100 ns; + if(led_pof_g /= '1') then + log("ERROR: POF Green LED must be HIGH.", VLOW); + error_flag <= true; + end if; + if(led_pof_y /= '0') then + log("ERROR: POF Yellow LED must be LOW.", VLOW); + error_flag <= true; + end if; + + for n in 0 to 8 loop + wait for 10 us; + wait until clk = '1' and clk'event; + pof <= not pof; + wait until clk = '1' and clk'event; + pof <= not pof; + end loop; -- n + + wait for 100 ns; + if(led_pof_g /= '1') then + log("ERROR: POF Green LED must be HIGH.", VLOW); + error_flag <= true; + end if; + if(led_pof_y /= '0') then + log("ERROR: POF Yellow LED must be LOW.", VLOW); + error_flag <= true; + end if; + + wait for 3 ms; + if(led_pof_g /= '0') then + log("ERROR: POF Green LED must be LOW.", VLOW); + error_flag <= true; + end if; + if(led_pof_y /= '0') then + log("ERROR: POF Yellow LED must be LOW.", VLOW); + error_flag <= true; + end if; + + wait for 3 ms; + if(led_pof_g /= '0') then + log("ERROR: POF Green LED must be LOW.", VLOW); + error_flag <= true; + end if; + if(led_pof_y /= '1') then + log("ERROR: POF Yellow LED must be HIGH.", VLOW); + error_flag <= true; + end if; + + wait for 50 ns; + if(error_flag = false) then + log("POF LEDs are OK.", VLOW); + end if; + + wait for 0.5 ms; + + end if; -- RUN_POF_TEST + + --------------------------------------------------------------------------- + -- PD LEDs + --------------------------------------------------------------------------- + + if(RUN_PD_TEST = true) then + + log_separator_line(VLOW); + log("Testing PD LEDs:", VLOW); + + pd <= '1'; + + wait for 100 ns; + if(led_pd_g /= '1') then + log("ERROR: PD Green LED must be HIGH.", VLOW); + error_flag <= true; + end if; + if(led_pd_y /= '0') then + log("ERROR: PD Yellow LED must be LOW.", VLOW); + error_flag <= true; + end if; + + wait for 1 us; + pd <= '0'; + wait for 1 us; + + wait for 3 ms; + if(led_pd_g /= '0') then + log("ERROR: PD Green LED must be LOW.", VLOW); + error_flag <= true; + end if; + if(led_pd_y /= '0') then + log("ERROR: PD Yellow LED must be LOW.", VLOW); + error_flag <= true; + end if; + + wait for 3 ms; + if(led_pd_g /= '0') then + log("ERROR: PD Green LED must be LOW.", VLOW); + error_flag <= true; + end if; + if(led_pd_y /= '1') then + log("ERROR: PD Yellow LED must be HIGH.", VLOW); + error_flag <= true; + end if; + + wait for 1.5 ms; + + pd <= '1'; + wait for 1 us; + pd <= '0'; + wait for 10 us; + pd <= '1'; + wait for 1 us; + pd <= '0'; + wait for 10 us; + pd <= '1'; + wait for 1 us; + pd <= '0'; + wait for 10 us; + pd <= '1'; + wait for 1 us; + pd <= '0'; + + if(led_pd_g /= '1') then + log("ERROR: PD Green LED must be HIGH.", VLOW); + error_flag <= true; + end if; + if(led_pd_y /= '0') then + log("ERROR: PD Yellow LED must be LOW.", VLOW); + error_flag <= true; + end if; + + wait for 3.0 ms; + + if(led_pd_g /= '0') then + log("ERROR: PD Green LED must be LOW.", VLOW); + error_flag <= true; + end if; + if(led_pd_y /= '0') then + log("ERROR: PD Yellow LED must be LOW.", VLOW); + error_flag <= true; + end if; + + wait for 3 ms; + if(led_pd_g /= '0') then + log("ERROR: PD Green LED must be LOW.", VLOW); + error_flag <= true; + end if; + if(led_pd_y /= '1') then + log("ERROR: PD Yellow LED must be HIGH.", VLOW); + error_flag <= true; + end if; + + wait for 50 ns; + if(error_flag = false) then + log("PD LEDs are OK.", VLOW); + end if; + + wait for 0.5 ms; + + end if; -- RUN_PD_TEST + + --------------------------------------------------------------------------- + -- Encoder LEDs + --------------------------------------------------------------------------- + + if(RUN_ENC_TEST = true) then + + log_separator_line(VLOW); + log("Testing Encoder LEDs:", VLOW); + wait for 5 us; + + if(led_enc_p1_y /= '0') then + log("ERROR: P1 Yellow LED must be LOW.", VLOW); + error_flag <= true; + end if; + + if(led_enc_p2_y /= '0') then + log("ERROR: P2 Yellow LED must be LOW.", VLOW); + error_flag <= true; + end if; + + if(led_enc_p1_g /= '0') then + log("ERROR: P1 Green LED must be LOW.", VLOW); + error_flag <= true; + end if; + + if(led_enc_p2_g /= '0') then + log("ERROR: P2 Green LED must be LOW.", VLOW); + error_flag <= true; + end if; + + if(led_enc_p1_r /= '0') then + log("ERROR: P1 Red LED must be LOW.", VLOW); + error_flag <= true; + end if; + + if(led_enc_p2_r /= '0') then + log("ERROR: P2 Red LED must be LOW.", VLOW); + error_flag <= true; + end if; + + wait for 1 us; + + enc_p1 <= '1'; + wait for 10 us; + enc_p2 <= '1'; + wait for 100 ns; + + if(led_enc_p1_g /= '1') then + log("ERROR: P1 Green LED must be HIGH.", VLOW); + error_flag <= true; + end if; + if(led_enc_p2_g /= '1') then + log("ERROR: P2 Green LED must be HIGH.", VLOW); + error_flag <= true; + end if; + if(led_enc_p1_y /= '0') then + log("ERROR: P1 Yellow LED must be LOW.", VLOW); + error_flag <= true; + end if; + if(led_enc_p2_y /= '0') then + log("ERROR: P2 Yellow LED must be LOW.", VLOW); + error_flag <= true; + end if; + + wait for 3 ms; + if(led_enc_p1_g /= '0') then + log("ERROR: P1 Green LED must be LOW.", VLOW); + error_flag <= true; + end if; + if(led_enc_p2_g /= '0') then + log("ERROR: P2 Green LED must be LOW.", VLOW); + error_flag <= true; + end if; + if(led_enc_p1_y /= '0') then + log("ERROR: P1 Yellow LED must be LOW.", VLOW); + error_flag <= true; + end if; + if(led_enc_p2_y /= '0') then + log("ERROR: P2 Yellow LED must be LOW.", VLOW); + error_flag <= true; + end if; + + wait for 3 ms; + if(led_enc_p1_g /= '0') then + log("ERROR: P1 Green LED must be LOW.", VLOW); + error_flag <= true; + end if; + if(led_enc_p2_g /= '0') then + log("ERROR: P2 Green LED must be LOW.", VLOW); + error_flag <= true; + end if; + if(led_enc_p1_y /= '1') then + log("ERROR: P1 Yellow LED must be HIGH.", VLOW); + error_flag <= true; + end if; + if(led_enc_p2_y /= '1') then + log("ERROR: P2 Yellow LED must be HIGH.", VLOW); + error_flag <= true; + end if; + + wait for 20 us; + + enc_p1 <= '0'; + wait for 100 ns; + if(led_enc_p1_g /= '1') then + log("ERROR: P1 Green LED must be HIGH.", VLOW); + error_flag <= true; + end if; + + wait for 3 ms; + if(led_enc_p1_g /= '0') then + log("ERROR: P1 Green LED must be LOW.", VLOW); + error_flag <= true; + end if; + + wait for 5 us; + enc_p1 <= '1'; + wait for 100 ns; + if(led_enc_p1_g /= '1') then + log("ERROR: P1 Green LED must be HIGH.", VLOW); + error_flag <= true; + end if; + wait for 10 us; + enc_p1 <= '0'; + wait for 10 us; + enc_p1 <= '1'; + wait for 10 us; + enc_p1 <= '0'; + wait for 10 us; + enc_p1 <= '1'; + wait for 10 us; + if(led_enc_p1_g /= '1') then + log("ERROR: P1 Green LED must be HIGH.", VLOW); + error_flag <= true; + end if; + + wait for 200 us; + enc_p2 <= '0'; + wait for 100 ns; + if(led_enc_p2_g /= '1') then + log("ERROR: P2 Green LED must be HIGH.", VLOW); + error_flag <= true; + end if; + + wait for 3 ms; + if(led_enc_p2_g /= '0') then + log("ERROR: P2 Green LED must be LOW.", VLOW); + error_flag <= true; + end if; + if(led_enc_p2_y /= '0') then + log("ERROR: P2 Yellow LED must be LOW.", VLOW); + error_flag <= true; + end if; + + wait for 3 ms; + if(led_enc_p2_g /= '0') then + log("ERROR: P2 Green LED must be LOW.", VLOW); + error_flag <= true; + end if; + if(led_enc_p2_y /= '1') then + log("ERROR: P2 Yellow LED must be HIGH.", VLOW); + error_flag <= true; + end if; + + wait for 10 us; + enc_p2 <= not enc_p2; + enc_p1 <= not enc_p1; + wait for 100 ns; + if(led_enc_p1_r /= '1') then + log("ERROR: P1 Red LED must be HIGH.", VLOW); + error_flag <= true; + end if; + if(led_enc_p2_r /= '1') then + log("ERROR: P2 Red LED must be HIGH.", VLOW); + error_flag <= true; + end if; + + wait for 6 ms; + wait for 100 ns; + if(led_enc_p1_r /= '0') then + log("ERROR: P1 Red LED must be LOW.", VLOW); + error_flag <= true; + end if; + if(led_enc_p2_r /= '0') then + log("ERROR: P2 Red LED must be LOW.", VLOW); + error_flag <= true; + end if; + if(led_enc_p1_y /= '1') then + log("ERROR: P1 Yellow LED must be HIGH.", VLOW); + error_flag <= true; + end if; + if(led_enc_p2_y /= '1') then + log("ERROR: P2 Yellow LED must be HIGH.", VLOW); + error_flag <= true; + end if; + + wait for 0.5 ms; + + if(error_flag = false) then + log("Encoder LEDs are OK.", VLOW); + end if; + + end if; -- RUN_ENC_TEST + + --------------------------------------------------------------------------- + -- End + --------------------------------------------------------------------------- + + wait for 20 us; + + passed <= true after 100 ns; + wait; + + end process pTEST_PROC; + + failed <= error_flag after 100 ns; + + CHECK_SIM_TIMEOUT: process + begin -- process CHECK_SIM_TIMEOUT + while now < MAX_SIM_TIME loop + wait for 100 us; + end loop; + test_timeout <= true; + wait; + end process CHECK_SIM_TIMEOUT; + + pREPORT_RESULT : process + begin + wait until failed = true or passed = true or test_timeout = true; + wait for 1 us; + log_separator_line(VLOW); + if(failed = true) then + log("FAILURE: test completed with errors.", VLOW); + elsif(passed = true) then + log("SUCCESS: test successfully completed.", VLOW); + elsif(test_timeout = true) then + log("FAILURE: test achieved max-sim-time without reaching ", VLOW); + log(" failed/passed condition.", VLOW); + end if; + log_separator_line(VLOW); + test_completed <= true; + end process pREPORT_RESULT; + + +end architecture behav; diff --git a/generic_ip/fire_pulse_manager/Readme.txt b/generic_ip/fire_pulse_manager/Readme.txt index 183d5c4..6467a16 100644 --- a/generic_ip/fire_pulse_manager/Readme.txt +++ b/generic_ip/fire_pulse_manager/Readme.txt @@ -14,4 +14,6 @@ Fire-Pulse-Manager major versions: - 5: FPM-5 fully replaces FPM-4. It Includes support for SEB-EPD => EMS block instantiated at place of POF-Rx block, based on the value of a VHDL generic. -- 6: Each FPM channel generates up to 32 sub-pixel phases \ No newline at end of file +- 6: Each FPM channel generates up to 32 sub-pixel phases + +- 8: fpga vendor independent. Uses enc_pd_emul_3, event_logger_2, epd_diagnostics_8, pof_protocol_3, pulse_generator_6 (all fpga vendor independent) \ No newline at end of file