Matiq/Adat
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

copy

Browse Source
This commit is contained in:
matiq
2026-03-13 19:58:28 +03:00
commit c938609393
87 changed files with 230200 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

587
gateware/debug.py Normal file
View File

@@ -0,0 +1,587 @@
from amaranth import *
from amaranth.lib.cdc import FFSynchronizer, PulseSynchronizer
from amlib.debug.ila import StreamILA, ILACoreParameters
from amlib.stream import StreamInterface
from amlib.io.led import NumberToBitBar
from amlib.io.max7219 import SerialLEDArray
from luna.gateware.usb.usb2.endpoints.stream import USBMultibyteStreamInEndpoint
def add_debug_led_array(v):
self = v['self']
m = v['m']
platform = v['platform']
channels_to_usb1_stream = v['channels_to_usb1_stream']
input_to_usb_fifo = v['input_to_usb_fifo']
usb1_to_output_fifo_level = v['usb1_to_output_fifo_level']
usb1_to_output_fifo_depth = v['usb1_to_output_fifo_depth']
usb2_to_usb1_fifo_level = v['usb2_to_usb1_fifo_level']
usb2_to_usb1_fifo_depth = v['usb2_to_usb1_fifo_depth']
channels_to_usb2_stream = v['channels_to_usb2_stream']
usb2_audio_out_active = v['usb2_audio_out_active']
usb2_audio_in_active = v['usb2_audio_in_active']
bundle_multiplexer = v['bundle_multiplexer']
adat_transmitters = v['adat_transmitters']
usb1_to_usb2_midi_fifo = v['usb1_to_usb2_midi_fifo']
usb2_to_usb1_midi_fifo = v['usb2_to_usb1_midi_fifo']
usb_midi_fifo_depth = v['usb_midi_fifo_depth']
adat1_underflow_count = Signal(16)
with m.If(adat_transmitters[0].underflow_out):
m.d.sync += adat1_underflow_count.eq(adat1_underflow_count + 1)
spi = platform.request("spi")
m.submodules.led_display = led_display = SerialLEDArray(divisor=10, init_delay=24e6, no_modules=2)
rx_level_bars = []
for i in range(1, 5):
rx_level_bar = NumberToBitBar(0, bundle_multiplexer.FIFO_DEPTH, 8)
setattr(m.submodules, f"rx{i}_level_bar", rx_level_bar)
m.d.comb += rx_level_bar.value_in.eq(bundle_multiplexer.levels[i - 1])
rx_level_bars.append(rx_level_bar)
m.submodules.in_bar = in_to_usb_fifo_bar = NumberToBitBar(0, self.INPUT_CDC_FIFO_DEPTH, 8)
m.submodules.in_fifo_bar = channels_to_usb_bar = NumberToBitBar(0, 2 * self.USB1_MAX_PACKET_SIZE, 8)
m.submodules.out_fifo_bar = out_fifo_bar = NumberToBitBar(0, usb1_to_output_fifo_depth, 8)
m.d.comb += [
# LED bar displays
in_to_usb_fifo_bar.value_in.eq(input_to_usb_fifo.r_level),
channels_to_usb_bar.value_in.eq(channels_to_usb1_stream.level >> 3),
out_fifo_bar.value_in.eq(usb1_to_output_fifo_level >> 1),
*[led_display.digits_in[i].eq(Cat(reversed(rx_level_bars[i].bitbar_out))) for i in range(4)],
led_display.digits_in[4].eq(Cat(reversed(in_to_usb_fifo_bar.bitbar_out))),
led_display.digits_in[5].eq(Cat(reversed(channels_to_usb_bar.bitbar_out))),
led_display.digits_in[6].eq(Cat(reversed(out_fifo_bar.bitbar_out))),
led_display.digits_in[7].eq(adat1_underflow_count),
]
usb2 = lambda x: 8 + x
m.submodules.usb2_output_fifo_bar = usb2_output_fifo_bar = NumberToBitBar(0, usb2_to_usb1_fifo_depth, 8)
m.submodules.usb2_input_fifo_bar = usb2_input_fifo_bar = NumberToBitBar(0, channels_to_usb2_stream._fifo_depth, 8)
m.submodules.usb2_to_usb1_bar = usb2_to_usb1_bar = NumberToBitBar(0, usb_midi_fifo_depth, 8)
m.submodules.usb1_to_usb2_bar = usb1_to_usb2_bar = NumberToBitBar(0, usb_midi_fifo_depth, 8)
m.d.comb += [
usb2_output_fifo_bar.value_in.eq(usb2_to_usb1_fifo_level),
usb2_input_fifo_bar.value_in.eq(channels_to_usb2_stream.level),
led_display.digits_in[usb2(0)][0].eq(usb2_audio_out_active),
led_display.digits_in[usb2(0)][7].eq(usb2_audio_in_active),
led_display.digits_in[usb2(1)].eq(Cat(usb2_output_fifo_bar.bitbar_out)),
led_display.digits_in[usb2(2)].eq(Cat(reversed(usb2_input_fifo_bar.bitbar_out))),
led_display.digits_in[usb2(3)].eq(usb2_to_usb1_bar.bitbar_out),
led_display.digits_in[usb2(4)].eq(usb1_to_usb2_bar.bitbar_out),
]
m.d.comb += [
*led_display.connect_to_resource(spi),
led_display.valid_in.eq(1),
]
def setup_ila(v, ila_max_packet_size, use_convolution):
examined_usb = "usb1"
m = v['m']
usb1_sof_counter = v['usb1_sof_counter']
usb1 = v['usb1']
usb1_ep3_in = v['usb1_ep3_in']
usb1_ep3_out = v['usb1_ep3_out']
usb2_ep3_in = v['usb2_ep3_in']
usb2_ep3_out = v['usb2_ep3_out']
ep1_out = v[f'{examined_usb}_ep1_out']
ep2_in = v[f'{examined_usb}_ep2_in']
channels_to_usb_stream = v[f'channels_to_{examined_usb}_stream']
usb_to_channel_stream = v[f'{examined_usb}_to_channel_stream']
usb1_audio_in_active = v['usb1_audio_in_active']
usb2_audio_out_active = v['usb2_audio_out_active']
input_to_usb_fifo = v['input_to_usb_fifo']
usb1_to_output_fifo = v['usb1_to_output_fifo']
usb1_to_output_fifo_level = v['usb1_to_output_fifo_level']
usb1_to_output_fifo_depth = v['usb1_to_output_fifo_depth']
audio_in_frame_bytes = v['usb2_audio_in_frame_bytes']
min_fifo_level = v['min_fifo_level']
max_fifo_level = v['max_fifo_level']
adat_transmitters = v['adat_transmitters']
adat_receivers = v['adat_receivers']
bundle_demultiplexer = v['bundle_demultiplexer']
bundle_multiplexer = v['bundle_multiplexer']
usb1_channel_stream_combiner = v['usb1_channel_stream_combiner']
usb1_channel_stream_splitter = v['usb1_channel_stream_splitter']
usb1_to_usb2_midi_fifo = v['usb1_to_usb2_midi_fifo']
usb2_to_usb1_midi_fifo = v['usb2_to_usb1_midi_fifo']
dac1_extractor = v['dac1_extractor']
dac1 = v['dac1']
convolver = v['convolver']
enable_convolver = v['enable_convolver']
adat_clock = Signal()
m.d.comb += adat_clock.eq(ClockSignal("adat"))
sof_wrap = Signal()
m.d.comb += sof_wrap.eq(usb1_sof_counter == 0)
usb_packet_counter = Signal(10)
with m.If(ep1_out.stream.valid & ep1_out.stream.ready):
m.d.usb += usb_packet_counter.eq(usb_packet_counter + 1)
with m.If(ep1_out.stream.last):
m.d.usb += usb_packet_counter.eq(0)
weird_packet = Signal()
m.d.comb += weird_packet.eq(ep1_out.stream.last & (
usb_packet_counter[0:2] != Const(0b11, 2)
))
strange_input = Signal()
input_active = Signal()
output_active = Signal()
input_or_output_active = Signal()
garbage = Signal()
usb_frame_borders = Signal()
m.d.comb += [
input_active.eq ( channels_to_usb_stream.channel_stream_in.ready
& channels_to_usb_stream.channel_stream_in.valid),
output_active.eq( channels_to_usb_stream.usb_stream_out.ready
& channels_to_usb_stream.usb_stream_out.valid),
input_or_output_active.eq(input_active | output_active),
strange_input.eq( (channels_to_usb_stream.channel_stream_in.payload != 0)
& (channels_to_usb_stream.channel_stream_in.channel_nr > 1)),
garbage.eq(channels_to_usb_stream.skipping | channels_to_usb_stream.filling),
usb_frame_borders.eq(ep2_in.data_requested | ep2_in.frame_finished),
]
fill_count = Signal(16)
with m.If(channels_to_usb_stream.filling):
m.d.usb += fill_count.eq(fill_count + 1)
channels_to_usb_input_frame = [
usb1.sof_detected,
input_to_usb_fifo.r_level,
channels_to_usb_stream.channel_stream_in.channel_nr,
channels_to_usb_stream.channel_stream_in.first,
channels_to_usb_stream.channel_stream_in.last,
input_active,
#channels_to_usb_stream.channel_stream_in.payload,
]
weird_frame_size = Signal()
usb_outputting = Signal()
m.d.comb += usb_outputting.eq(ep1_out.stream.valid & ep1_out.stream.ready)
usb_out_level_maxed = Signal()
m.d.comb += usb_out_level_maxed.eq(usb1_to_output_fifo_level >= (usb1_to_output_fifo_depth - 1))
m.d.comb += weird_frame_size.eq((audio_in_frame_bytes & 0b11) != 0)
channels_to_usb_debug = [
usb2_audio_out_active,
audio_in_frame_bytes,
channels_to_usb_stream.current_channel,
channels_to_usb_stream.channel_stream_in.ready,
channels_to_usb_stream.level,
channels_to_usb_stream.fifo_full,
channels_to_usb_stream.fifo_level_insufficient,
channels_to_usb_stream.out_channel,
channels_to_usb_stream.fifo_read,
channels_to_usb_stream.usb_channel,
channels_to_usb_stream.done,
channels_to_usb_stream.usb_byte_pos,
channels_to_usb_stream.skipping,
channels_to_usb_stream.filling,
ep2_in.data_requested,
ep2_in.frame_finished,
channels_to_usb_stream.usb_stream_out.valid,
channels_to_usb_stream.usb_stream_out.ready,
channels_to_usb_stream.usb_stream_out.first,
channels_to_usb_stream.usb_stream_out.last,
channels_to_usb_stream.usb_stream_out.payload,
]
usb_out_debug = [
usb_to_channel_stream.channel_stream_out.payload,
usb_to_channel_stream.channel_stream_out.channel_nr,
usb_to_channel_stream.channel_stream_out.first,
usb_to_channel_stream.channel_stream_out.last,
#usb1_to_output_fifo_level,
#usb_out_level_maxed
]
usb_channel_outputting = Signal()
m.d.comb += usb_channel_outputting.eq(
usb_out_level_maxed |
usb_to_channel_stream.channel_stream_out.first |
usb_to_channel_stream.channel_stream_out.last |
( usb_to_channel_stream.channel_stream_out.ready &
usb_to_channel_stream.channel_stream_out.valid)
)
ep1_out_fifo_debug = [
audio_in_frame_bytes,
min_fifo_level,
usb1_to_output_fifo_level,
max_fifo_level,
usb1.sof_detected,
]
adat_nr = 0
receiver_debug = [
adat_receivers[adat_nr].sample_out,
adat_receivers[adat_nr].addr_out,
adat_receivers[adat_nr].output_enable,
#adat_receivers[adat_nr].recovered_clock_out,
]
adat_first = Signal()
m.d.comb += adat_first.eq(adat_receivers[adat_nr].output_enable & (adat_receivers[adat_nr].addr_out == 0))
adat_clock = Signal()
m.d.comb += adat_clock.eq(ClockSignal("adat"))
adat_debug = [
adat_clock,
adat_transmitters[adat_nr].adat_out,
adat_receivers[adat_nr].recovered_clock_out,
adat_receivers[adat_nr].adat_in,
adat_first,
adat_receivers[adat_nr].output_enable,
]
adat_transmitter_debug = [
adat_clock,
bundle_demultiplexer.bundles_out[adat_nr].channel_nr,
adat_transmitters[adat_nr].sample_in,
adat_transmitters[adat_nr].valid_in,
adat_transmitters[adat_nr].last_in,
adat_transmitters[adat_nr].ready_out,
adat_transmitters[adat_nr].fifo_level_out,
adat_transmitters[adat_nr].underflow_out,
adat_transmitters[adat_nr].adat_out,
]
bundle0_active = Signal()
bundle3_active = Signal()
bundle_multiplexer_active = Signal()
multiplexer_enable = Signal()
m.d.comb += [
bundle0_active.eq((bundle_multiplexer.bundles_in[0].valid &
bundle_multiplexer.bundles_in[0].ready)),
bundle3_active.eq((bundle_multiplexer.bundles_in[3].valid &
bundle_multiplexer.bundles_in[3].ready)),
bundle_multiplexer_active.eq((bundle_multiplexer.channel_stream_out.valid &
bundle_multiplexer.channel_stream_out.ready)),
multiplexer_enable.eq(bundle0_active | bundle3_active | bundle_multiplexer_active),
]
multiplexer_debug = [
bundle_multiplexer.current_bundle,
bundle_multiplexer.last_bundle,
bundle0_active,
#bundle_multiplexer.bundles_in[0].payload,
bundle_multiplexer.bundles_in[0].channel_nr,
bundle_multiplexer.bundles_in[0].last,
bundle3_active,
#bundle_multiplexer.bundles_in[3].payload,
bundle_multiplexer.bundles_in[3].channel_nr,
bundle_multiplexer.bundles_in[3].last,
#bundle_multiplexer.channel_stream_out.payload,
bundle_multiplexer_active,
bundle_multiplexer.channel_stream_out.channel_nr,
bundle_multiplexer.channel_stream_out.last,
input_to_usb_fifo.w_level,
]
demultiplexer_debug = [
bundle_demultiplexer.channel_stream_in.ready,
bundle_demultiplexer.channel_stream_in.valid,
bundle_demultiplexer.channel_stream_in.channel_nr,
#bundle_demultiplexer.channel_stream_in.payload,
*[bundle_demultiplexer.bundles_out[i].ready for i in range(4)],
*[bundle_demultiplexer.bundles_out[i].valid for i in range(4)],
*[bundle_demultiplexer.bundles_out[i].channel_nr for i in range(4)],
]
demultiplexer_enable = Signal()
m.d.comb += demultiplexer_enable.eq(
(bundle_demultiplexer.bundles_out[0].valid &
bundle_demultiplexer.bundles_out[0].ready) |
(bundle_demultiplexer.bundles_out[3].valid &
bundle_demultiplexer.bundles_out[3].ready) |
(bundle_demultiplexer.channel_stream_in.valid &
bundle_demultiplexer.channel_stream_in.ready)
)
levels = [
input_to_usb_fifo.r_level,
channels_to_usb_stream.level,
]
adat_transmit_count = Signal(8)
adat_transmit_frames = Signal.like(adat_transmit_count)
adat_receiver0_count = Signal.like(adat_transmit_count)
adat_receiver0_frames = Signal.like(adat_transmit_count)
adat_receiver3_count = Signal.like(adat_transmit_count)
adat_receiver3_frames = Signal.like(adat_transmit_count)
adat_multiplexer_count = Signal.like(adat_transmit_count)
adat_multiplexer_frames = Signal.like(adat_transmit_count)
adat_channels2usb_count = Signal.like(adat_transmit_count)
adat_channels2usb_frames = Signal.like(adat_transmit_count)
usb_receive_frames = Signal.like(adat_transmit_count)
m.submodules.sof_synchronizer = sof_synchronizer = PulseSynchronizer("usb", "fast")
sof_fast = Signal()
adat_receiver0_fast = Signal()
adat_receiver3_fast = Signal()
adat_multiplexer_out_fast = Signal()
m.d.comb += [
sof_synchronizer.i.eq(usb1.sof_detected),
sof_fast.eq(sof_synchronizer.o),
adat_receiver0_fast.eq((adat_receivers[0].addr_out == 7) & adat_receivers[0].output_enable),
adat_receiver3_fast.eq((adat_receivers[3].addr_out == 7) & adat_receivers[3].output_enable),
adat_multiplexer_out_fast.eq(bundle_multiplexer.channel_stream_out.ready & bundle_multiplexer.channel_stream_out.valid & bundle_multiplexer.channel_stream_out.last),
]
with m.If(sof_fast):
m.d.fast += [
adat_receiver0_frames.eq(adat_receiver0_count),
adat_receiver0_count.eq(0),
adat_receiver3_frames.eq(adat_receiver3_count),
adat_receiver3_count.eq(0),
adat_multiplexer_frames.eq(adat_multiplexer_count),
adat_multiplexer_count.eq(0),
]
with m.If(adat_receiver0_fast):
m.d.fast += adat_receiver0_count.eq(adat_receiver0_count + 1)
with m.If(adat_receiver3_fast):
m.d.fast += adat_receiver3_count.eq(adat_receiver3_count + 1)
with m.If(adat_multiplexer_out_fast):
m.d.fast += adat_multiplexer_count.eq(adat_multiplexer_count + 1)
frame_counts = [
adat_transmit_frames,
adat_receiver0_frames,
adat_receiver3_frames,
adat_multiplexer_frames,
adat_channels2usb_frames,
usb_receive_frames,
]
with m.If(channels_to_usb_stream.channel_stream_in.last & channels_to_usb_stream.channel_stream_in.valid & channels_to_usb_stream.channel_stream_in.ready):
m.d.usb += adat_channels2usb_count.eq(adat_channels2usb_count + 1)
with m.If(usb_to_channel_stream.channel_stream_out.last & usb_to_channel_stream.channel_stream_out.valid & usb_to_channel_stream.channel_stream_out.ready):
m.d.usb += adat_transmit_count.eq(adat_transmit_count + 1)
with m.If(usb1.sof_detected):
m.d.usb += [
adat_transmit_frames.eq(adat_transmit_count),
adat_transmit_count.eq(0),
adat_channels2usb_frames.eq(adat_channels2usb_count),
adat_channels2usb_count.eq(0),
usb_receive_frames.eq(audio_in_frame_bytes >> 7),
]
channel_stream_combiner_debug = [
#usb1_channel_stream_combiner.lower_channel_stream_in.valid,
#usb1_channel_stream_combiner.lower_channel_stream_in.ready,
#usb1_channel_stream_combiner.lower_channel_stream_in.payload,
#usb1_channel_stream_combiner.lower_channel_stream_in.channel_nr,
#usb1_channel_stream_combiner.lower_channel_stream_in.first,
#usb1_channel_stream_combiner.lower_channel_stream_in.last,
usb2_audio_out_active,
usb1_channel_stream_combiner.upper_channel_stream_in.valid,
usb1_channel_stream_combiner.upper_channel_stream_in.ready,
usb1_channel_stream_combiner.upper_channel_stream_in.payload,
usb1_channel_stream_combiner.upper_channel_stream_in.channel_nr,
usb1_channel_stream_combiner.upper_channel_stream_in.first,
usb1_channel_stream_combiner.upper_channel_stream_in.last,
usb1_channel_stream_combiner.upper_channel_counter,
usb1_channel_stream_combiner.state,
#usb1_channel_stream_combiner.combined_channel_stream_out.valid,
#usb1_channel_stream_combiner.combined_channel_stream_out.ready,
#usb1_channel_stream_combiner.combined_channel_stream_out.payload,
#usb1_channel_stream_combiner.combined_channel_stream_out.channel_nr,
#usb1_channel_stream_combiner.combined_channel_stream_out.first,
#usb1_channel_stream_combiner.combined_channel_stream_out.last,
]
upper_channel_active = Signal()
channel_stream_combiner_active = Signal()
m.d.comb += [
upper_channel_active.eq(usb1_channel_stream_combiner.upper_channel_stream_in.valid &
usb1_channel_stream_combiner.upper_channel_stream_in.ready),
channel_stream_combiner_active.eq(
upper_channel_active |
(usb1_channel_stream_combiner.combined_channel_stream_out.valid &
usb1_channel_stream_combiner.combined_channel_stream_out.ready) |
(usb1_channel_stream_combiner.lower_channel_stream_in.valid &
usb1_channel_stream_combiner.lower_channel_stream_in.ready))
]
channel_stream_splitter_debug = [
usb1_channel_stream_splitter.lower_channel_stream_out.valid,
usb1_channel_stream_splitter.lower_channel_stream_out.ready,
usb1_channel_stream_splitter.lower_channel_stream_out.payload,
usb1_channel_stream_splitter.lower_channel_stream_out.channel_nr,
usb1_channel_stream_splitter.lower_channel_stream_out.first,
usb1_channel_stream_splitter.lower_channel_stream_out.last,
usb2_audio_out_active,
usb1_channel_stream_splitter.upper_channel_stream_out.valid,
usb1_channel_stream_splitter.upper_channel_stream_out.ready,
usb1_channel_stream_splitter.upper_channel_stream_out.payload,
usb1_channel_stream_splitter.upper_channel_stream_out.channel_nr,
usb1_channel_stream_splitter.upper_channel_stream_out.first,
usb1_channel_stream_splitter.upper_channel_stream_out.last,
usb1_channel_stream_splitter.combined_channel_stream_in.valid,
usb1_channel_stream_splitter.combined_channel_stream_in.ready,
usb1_channel_stream_splitter.combined_channel_stream_in.payload,
usb1_channel_stream_splitter.combined_channel_stream_in.channel_nr,
usb1_channel_stream_splitter.combined_channel_stream_in.first,
usb1_channel_stream_splitter.combined_channel_stream_in.last,
]
splitter_upper_channel_active = Signal()
channel_stream_splitter_active = Signal()
m.d.comb += [
splitter_upper_channel_active.eq(usb1_channel_stream_splitter.upper_channel_stream_out.valid &
usb1_channel_stream_splitter.upper_channel_stream_out.ready),
channel_stream_splitter_active.eq(
splitter_upper_channel_active |
(usb1_channel_stream_splitter.combined_channel_stream_in.valid &
usb1_channel_stream_splitter.combined_channel_stream_in.ready) |
(usb1_channel_stream_splitter.lower_channel_stream_out.valid &
usb1_channel_stream_splitter.lower_channel_stream_out.ready))
]
midi_in_active = Signal()
m.d.comb += midi_in_active.eq(usb2_ep3_in.stream.valid & usb2_ep3_in.stream.ready)
midi_out_active = Signal()
m.d.comb += midi_out_active.eq(usb2_ep3_out.stream.valid & usb2_ep3_out.stream.ready)
midi_active = Signal()
m.d.comb += midi_active.eq(midi_in_active | midi_out_active)
midi_out_stream = StreamInterface(name="midi_out")
m.d.comb += midi_out_stream.stream_eq(usb2_ep3_out.stream, omit="ready")
midi_in_stream = StreamInterface(name="midi_in")
m.d.comb += midi_in_stream.stream_eq(usb1_ep3_in.stream, omit="ready")
in_ready = Signal()
m.d.comb += in_ready.eq(usb1_ep3_in.stream.ready)
midi_out = [
usb2_ep3_out.stream.ready,
usb2_ep3_out.stream.valid,
midi_out_stream.payload,
midi_out_stream.first,
midi_out_stream.last,
usb2_to_usb1_midi_fifo.r_level,
in_ready,
midi_in_stream.valid,
midi_in_stream.payload,
midi_in_stream.first,
midi_in_stream.last,
]
dac_extractor_debug = [
#dac1_extractor.selected_channel_in,
dac1_extractor.level,
dac1_extractor.channel_stream_in.channel_nr,
#dac1_extractor.channel_stream_in.payload,
dac1_extractor.channel_stream_in.valid,
#dac1_extractor.channel_stream_out.payload,
#dac1_extractor.channel_stream_out.valid,
dac1_extractor.channel_stream_out.ready,
dac1_extractor.channel_stream_out.first,
dac1_extractor.channel_stream_out.last,
dac1.underflow_out,
dac1.fifo_level_out,
enable_convolver,
]
convolver_signal_in_valid = Signal()
convolver_signal_in_first = Signal()
convolver_signal_in_last = Signal()
convolver_signal_in_ready = Signal()
convolver_signal_in_payload = Signal(signed(24))
convolver_signal_out_valid = Signal()
convolver_signal_out_first = Signal()
convolver_signal_out_last = Signal()
convolver_signal_out_payload = Signal(24)
convolver_signal_out_ready = Signal()
if use_convolution:
m.d.comb += [
convolver_signal_in_valid.eq(convolver.signal_in.valid),
convolver_signal_in_first.eq(convolver.signal_in.first),
convolver_signal_in_last.eq(convolver.signal_in.last),
convolver_signal_in_payload.eq(convolver.signal_in.payload),
convolver_signal_in_ready.eq(convolver.signal_in.ready),
convolver_signal_out_valid.eq(convolver.signal_out.valid),
convolver_signal_out_first.eq(convolver.signal_out.first),
convolver_signal_out_last.eq(convolver.signal_out.last),
convolver_signal_out_payload.eq(convolver.signal_out.payload),
convolver_signal_out_ready.eq(convolver.signal_out.ready),
]
convolution_debug = [
convolver_signal_in_ready,
convolver_signal_in_valid,
convolver_signal_in_first,
convolver_signal_in_last,
convolver_signal_in_payload,
convolver_signal_out_valid,
convolver_signal_out_first,
convolver_signal_out_last,
convolver_signal_out_payload,
convolver_signal_out_ready,
dac1_extractor.level,
enable_convolver,
]
#
# signals to trace
#
signals = adat_transmitter_debug
signals_bits = sum([s.width for s in signals])
m.submodules.ila = ila = \
StreamILA(
domain="usb", o_domain="usb",
#sample_rate=60e6, # usb domain
#sample_rate=48e3 * 256 * 5, # sync domain
#sample_rate=48e3 * 256 * 9, # fast domain
#sample_rate=25e6 * 29 / 7, # fast domain, ECP5
signals=signals,
sample_depth = int(10 * 8 * 1024 / signals_bits),
samples_pretrigger = 2, #int(78 * 8 * 1024 / signals_bits),
with_enable=True)
stream_ep = USBMultibyteStreamInEndpoint(
endpoint_number=4, # EP 4 IN
max_packet_size=ila_max_packet_size,
byte_width=ila.bytes_per_sample
)
usb1.add_endpoint(stream_ep)
m.d.comb += [
stream_ep.stream.stream_eq(ila.stream),
# ila.enable.eq(input_or_output_active | garbage | usb_frame_borders),
ila.trigger.eq(1),
ila.enable .eq(input_or_output_active),
]
ILACoreParameters(ila).pickle()