ABV Labs
HomeProductsResourcesSupport & CommunityResellersContact

Tutorial

Quadrature Encoder

Configure a supported quadrature pair, reset position and read signed encoder counts.

SignalDAQ 2421

Documentation edition: SignalDAQ SDK 0.13.0 — Current

Choose another edition

Configure a supported quadrature pair, reset position and read signed encoder counts.

ExampleTask
1configure and read a quadrature encoder

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
EncoderModeX2=2, X4=4

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. Encoder pairs are A4/A3, A6/A5, B4/B3, B6/B5; A-line selection identifies Read/Reset.

Connect encoder channel A to A6 and B to A5, using compatible signal levels and the correct reference. Configure X4 decoding, reset position, and read its signed count.

Read and Reset select the configured A line; the SDK resolves its timer. Supported A/B pairs are A4/A3, A6/A5, B4/B3 and B6/B5. Pair order matters. Modes are X2 or X4.

Simulator position is zero because it has no moving encoder input. Hardware position is a signed 16-bit or 32-bit timer count depending on the selected timer; the SDK does not extend rollover or convert to distance/angle. Configure also resets the count.

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_a=[s.DigitalLine.A6]
    status=s.configure_encoder(handle,lines_a,[s.DigitalLine.A5],[s.EncoderMode.X4])
    if status!=0: return report(status)
    status=s.reset_encoder(handle,lines_a)
    if status!=0: return report(status)
    time.sleep(0.1)
    status,positions=s.read_encoder(handle,lines_a)
    if status!=0: return report(status)
    print("Encoder position counts:",positions)
    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_encodersdaq_encoder_configureConfigureEncoder
read_encodersdaq_encoder_readReadEncoder
reset_encodersdaq_encoder_resetResetEncoder
SettingBehavior
ModeX2=2 or X4=4; Configure resets position.
SelectionMatching ordered A/B pair arrays and mode array. Read/Reset select A lines.
PositionSigned hardware count; no rollover extension or automatic angle conversion.
Deadline3 seconds per selected command.

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