ABV Labs
HomeProductsResourcesSupport & CommunityResellersContact

Tutorial

Digital Time Measurement

Measure signal periods using captured ticks and time units, and understand pulse-width capture behavior.

SignalDAQ 2421

Documentation edition: SignalDAQ SDK 0.13.0 — Current

Choose another edition

Measure signal periods using captured ticks and time units, and understand pulse-width capture behavior.

ExampleTask
1measure the period of an input signal

Use SDK 0.13.0 and firmware 1.1.36, the development pairing documented by this SDK. This is a breaking wrapper/read API update; rebuild callers and use the matching DLL. Use Windows 10 or later, the SignalDAQ WinUSB driver for hardware, and an x64 or x86 DLL matching the calling process. Close other SignalDAQ applications before opening hardware.

All complete examples open the simulator by default. It opens no USB device and generates no physical voltage. Simulation checks API usage and software state, not analog accuracy, electrical timing, throughput, or waveform integrity.

Device operations take an explicit handle and return signed status: 0 is success; AI/DIO stream reads also return +1 at normal finite EOF. Python returns status first when data is returned; C# uses out parameters; C uses output pointers. Check status before using outputs, and preserve partial stream-read data/counts on errors. These APIs do not automatically throw status errors. Loader/runtime failures and some utility helpers can still raise exceptions.

Use a suitable signal source, meter or scope and the correct reference for the selected digital terminals. Verify electrical levels, loading and protection limits in the product manual before wiring; these tutorials do not infer them from analog voltage ranges. Disconnect competing output drivers. Pulse examples should first use an input-only load, not an actuator.

The complete programs take ownership of their named banks and return those entire banks to GPIO Input before work and during cleanup. This also releases specialty timer ownership. Do not adapt this cleanup to a shared bank without deciding which application owns it.

Use Python 3.9 or later. Install the wrapper from the SDK folder with python -m pip install ./wrappers/python. The worked programs import signaldaq as s; they use module functions, not Device analog methods. Keep the same environment for installation and execution.

Use a .NET 8 console project with a project reference to wrappers/csharp/SignalDAQ/SignalDAQ.csproj. The examples use SignalDAQ.Analog static methods and C# top-level statements. Set SIGNALDAQ_DLL to the absolute path of bin/x64/signaldaq.dll for an x64 process, or the x86 DLL for an x86 process. Read the examples before following the run commands below.

Use a Windows C compiler, include/signaldaq.h, the matching lib/x64/signaldaq.lib or lib/x86/signaldaq.lib, and the matching DLL beside the executable. Examples use C11 and the Windows timing API. The full header includes every handle, count and output parameter.

EnumNamed values
DigitalLineA0=0, A1=1, A2=2, A3=3, A4=4, A5=5, A6=6, B0=7, B1=8, B2=9, B3=10, B4=11, B5=12, B6=13, Unused=255
TimeModePeriod=1, PulseWidth=2
DigitalEdgeRising=0, Falling=1, Both=2

Individual lines A0..A6 map to 0..6 and B0..B6 to 7..13. Supported timer-backed lines are A2, A4, A6, B4 and B6. Use enum selections rather than hardware timer IDs.

Connect a permitted repeating signal to A6. Configure Period with Rising edges, reset measurement state, and read the captured interval.

The result includes ticks, rounded integer microseconds, tick_hz and prescaler. Microseconds can be zero for sub-microsecond intervals; use ticks/tick_hz for finer numerical interpretation. This does not establish absolute hardware accuracy.

Simulator values are 108000 ticks, 1000 microseconds, 108000000 ticks/s, and prescaler 0. Hardware requires actual edges; missing input returns a firmware error. For PulseWidth mode, firmware uses its fixed PWM-input capture polarity rather than selecting pulse polarity with the edge argument.

This example owns bank A and resets that entire selection to GPIO Input before the example and during cleanup. Run separately; do not use it on a bank owned by another task.

Code example

import math
import sys
import time
import signaldaq as s

def report(status):
    print(f"SDK status {status}: {s.status_message(status)}", file=sys.stderr)
    return status

def run_example(handle):
    status = s.configure_dio_direction(handle, [s.DIOBank.A], [s.DIODirection.Input] * 1)
    if status != 0: return report(status)
    lines=[s.DigitalLine.A6]
    status=s.configure_time(handle,lines,[s.TimeMode.Period],[s.DigitalEdge.Rising])
    if status!=0: return report(status)
    status=s.reset_time(handle,lines)
    if status!=0: return report(status)
    status,result=s.read_time(handle,lines)
    if status!=0: return report(status)
    seconds=result['ticks'][0]/result['tick_hz'][0]
    print("Period:",result['microseconds'][0],"us; ticks/tick_hz:",seconds,"s")
    return 0

def main():
    status, handle = s.open_simulated()
    if status != 0:
        report(status)
        return 1
    result = 0
    try:
        result = run_example(handle)
    finally:
        # Attempt every cleanup operation, even when an earlier one fails.
        cleanup = [
            ("Return owned banks to Input", s.configure_dio_direction(handle, [s.DIOBank.A], [s.DIODirection.Input] * 1)),
            ("Close", s.close_device(handle)),
        ]
        for label, status in cleanup:
            if status != 0:
                print(label, file=sys.stderr)
                report(status)
                if result == 0:
                    result = status
    return 0 if result == 0 else 1

if __name__ == "__main__":
    raise SystemExit(main())

Each worked listing is a complete independent program. Copy one language tab into a file; do not combine several listings or paste API reference declarations into a program. Run the simulator first. Cleanup checks Stop, output reset where applicable, and Close even after an earlier operation fails.

python -m pip install ./wrappers/python
python example.py

For hardware, replace s.open_simulated() with s.open_device() or s.open_device("YOUR_SERIAL"). Both return (status, handle); leave explicit handle arguments and status checks in place.

# PowerShell from the SDK folder; use an x64 process.
dotnet new console -n SdkExample -f net8.0
dotnet add ./SdkExample/SdkExample.csproj reference ./wrappers/csharp/SignalDAQ/SignalDAQ.csproj
# Replace SdkExample/Program.cs with one complete C# listing.
$env:SIGNALDAQ_DLL = (Resolve-Path ./bin/x64/signaldaq.dll).Path
dotnet run --project ./SdkExample/SdkExample.csproj

For hardware, replace Analog.OpenSimulated(out uint handle) with Analog.Open(null, out uint handle), or supply a serial string instead of null. Every analog method returns status explicitly. The listing uses application-level Report helpers; the SDK does not throw analog status errors automatically.

cl /nologo /W4 /std:c11 /I include example.c /link lib/x64/signaldaq.lib
copy bin\x64\signaldaq.dll .
example.exe

Run the C commands in an x64 Visual Studio Developer Command Prompt from the SDK folder. For hardware, replace sdaq_open_simulated(&handle) with sdaq_open(NULL, &handle), or pass a serial string. Match the compiler target, import library and DLL architecture.

PythonCC# Digital
configure_timesdaq_time_configureConfigureTime
read_timesdaq_time_readReadTime
reset_timesdaq_time_resetResetTime
Result or settingMeaning
Period=1Capture an interval between selected edges.
PulseWidth=2Firmware PWM-input capture with fixed capture polarity.
ticks / tick_hzCaptured interval in seconds, using timer counts.
microsecondsRounded integer interval; can be zero below 1 us.
prescalersTimer prescaler metadata, one value per selection.
DeadlineUp to 20 seconds per selected Read to allow capture retries; missing input returns a firmware error.

All selections/settings are matching arrays except scalar Pulse Run. Validate every array before commands. Firmware applies selected commands in order, not as an atomic or synchronized batch. Later failure can leave earlier effects applied; do not automatically retry destructive measurements, resets or generated output. Native fixed-read outputs stay unchanged on failure; wrappers return empty arrays or None/null.

The selected line determines the hardware timer. Specialty input/output directions must be compatible across the whole bank, and timers cannot be used by incompatible modes at once. Per-handle specialty guards return Busy for concurrent specialty calls. HID traffic is serialized, so a long capture/gate/train can delay other command replies. Close does not release PWM or abort a running firmware operation. The complete examples reset only the entire banks they own to GPIO Input during cleanup.

SDK 0.13.0: include/signaldaq.h; wrappers/python/signaldaq/init.py; wrappers/csharp/SignalDAQ/Analog.cs, Digital.cs, Specialty.cs, Native.cs; ANALOG_API_0_9_0.md; DIO_API.md; DIGITAL_SPECIALTY_API.md; TIMEOUT_POLICY.md. Firmware 1.1.36: SignalDAQ 2421/Software/Core/Inc/daq_protocol.h and Core/Src/daq_app.c, dio.c, dac80502_sai.c. Existing analog API documentation version names are historical; current public signatures come from this SDK source.

Worked listings are validated with the SDK simulator, not physical hardware. LabVIEW import headers and DLLs are current; binary VI regeneration and execution remain pending. No LabVIEW diagram or fabricated textual diagram is included.

Related resources