Lab 23 - Waveform digitizer

In this lab, we explore how to capture waveforms using the Digitizer component in SciCompiler, adding the hits (64-bit) and timestamp (64-bit) fields so we can store additional information about each acquired waveform. Below is a high-level explanation of the hardware/firmware design, steps to configure it, and a Python script using SciSDK to acquire data.

1. Firmware Block Diagram

Here is a simplified block diagram of the waveform digitizer design:

• ADC Data: Each channel (e.g. 16-bit wide) feeds into the Digitizer’s IN port.
• TIMESTAMP: A 64-bit system or board time is connected to the Digitizer’s TIMESTAMP input.
• HITS: A 64-bit signal indicating which channel(s) triggered, or other status info.
• USER: A 32-bit general-purpose field (optional) that can carry any user-defined data.
• CE (Clock Enable): A signal (1-bit) enabling sampling on each clock cycle if CE is high.
• START: A 1-bit trigger that initiates the capture of one waveform (or multiple, depending on design).
• BUSY, FULL, ACCEPTED, REJECTED, ERROR: Status outputs from the Digitizer indicating whether the block is busy, memory is full, the trigger is accepted or rejected, etc.

Within SciCompiler, you can configure:

• The number of channels (up to the design’s maximum).
• The size (in samples) of each captured waveform.
• Timing and triggering conditions (e.g., the START signal source).

Below is another view of the schematic showing how the signals are wired:

2. Configuring the Digitizer

1. Compile-Time Channel Configuration:
   In SciCompiler, choose how many maximum channels your design supports (e.g., 4, 8, 16). This sets the internal width and FIFO resources.

2. Runtime Channel Selection:
   At runtime, you can choose N channels (from channel 0 upwards). For example, if N = 2, channels 0 and 1 are acquired; if N = 4, channels 0, 1, 2, 3 are acquired, etc.

3. Waveform Length:
   Specify how many samples per waveform you wish to acquire (e.g., 1000 samples). This can also be set at runtime in the driver/API as SetLen.

4. Timestamp & Hits:

   • TIMESTAMP is latched on the rising edge of START.
   • HITS is also captured at that moment, allowing you to log which channel fired or any status bits.

5. Start / Trigger:

   • The START pin is driven by your chosen trigger logic. In the example below, a pulse generator triggers periodically.

6. Data Output:
   The digitizer packs each event’s data (timestamp, hits, user, waveform samples) into an output FIFO, which you then read via the Resource Explorer or an API (e.g., SciSDK in Python).

Below is a partial screenshot showing further parameter setup:

And the addresses or runtime parameters can be adjusted here:

3. Data acquisition using Resource Explorer

Digitizer data can be acquired using the Resource Explorer.

5. Reading Data in Python Using SciSDK

We will use the SciSDK library to:

1. Connect to the board.
2. Configure the digitizer parameters (channel enable, waveform length, etc.).
3. Generate triggers (if needed) or set up external triggers.
4. Acquire data from the digitizer’s FIFO.
5. Decode the waveforms, timestamps, and hits in Python.

Below is a minimal example script in Python:

from random import randint
from unicodedata import decimal
import matplotlib.pyplot as plt
import matplotlib.animation as animation
import os
from scisdk.scisdk import SciSDK
from scisdk.scisdk_defines import *

fig = plt.figure("Digitizer analog data - channel 0")
ax1 = fig.add_subplot(1,1,1)

# initialize scisdk library
sdk = SciSDK()

#DT1260
res = sdk.AddNewDevice("usb:10500","dt1260", "./RegisterFile.json","board0")


if res != 0:
    print ("Script exit due to connetion error")
    exit()

enabled_channels = 1
# set oscilloscope parameters
res = sdk.SetParameterString("board0:/MMCComponents/Digitizer_0.data_processing","decode")
res = sdk.SetParameterInteger("board0:/MMCComponents/Digitizer_0.enabledch", enabled_channels)
res = sdk.SetParameterInteger("board0:/MMCComponents/Digitizer_0.acq_len", 8000)
res = sdk.SetParameterString("board0:/MMCComponents/Digitizer_0.acq_mode", "blocking")
res = sdk.SetParameterInteger("board0:/MMCComponents/Digitizer_0.timeout", 2000)
res = sdk.ExecuteCommand("board0:/MMCComponents/Digitizer_0.start", "")
# allocate buffer for oscilloscope
res, buf = sdk.AllocateBuffer("board0:/MMCComponents/Digitizer_0")

def updateGraph(i, buffer): # function that provides to plot new data on graph
    res, buffer = sdk.ReadData("board0:/MMCComponents/Digitizer_0", buffer)# read data from board
    if res == 0:
        xar = []
        yar = []
        for index in range(buffer.info.valid_samples):
            xar.append(index)
            yar.append(buffer.analog[index])
        ax1.clear()
        ax1.plot(xar,yar)

# update graph every 50ms
ani = animation.FuncAnimation(fig, updateGraph, fargs=[buf],interval=200)
# updateGraph(None, buf, decimator)
plt.show()

Key Points in the Script

• AddNewDevice: Connects to the hardware (e.g., via USB or Ethernet).
• SetParameterString / SetParameterInteger: Configure digitizer properties (channel count, waveform length, etc.).
• AllocateBuffer: Prepares a memory buffer for data.
• start_acquisition / stop_acquisition: Arm or stop the digitizer.
• ReadData: Fetches the next event from the FIFO. If a valid event is present, it’s copied into the buffer.

For more details on the data structure and advanced usage, see the official SciSDK digitizer documentation.

4. Conclusion

By combining the Digitizer block with a hits bus and timestamp, you can capture detailed waveform information alongside which channels triggered and the global time of each event. This design allows flexible runtime configuration (channel enable, waveform length) and provides a simple readout path via SciSDK in Python.

1. Compile the design in SciCompiler with enough channels, connect your signals (ADC, hits, timestamp) appropriately.
2. Configure the digitizer at runtime (channel count, waveform length, etc.).
3. Trigger waveforms (using an external or internal START signal).
4. Acquire waveforms + metadata (hits, timestamp) using the SciSDK library.