Read voltages or decoded ADC codes with explicit handles, status checks, finite acquisitions and continuous input.
| Example | Task |
|---|---|
| 1 | read one voltage |
| 2 | read multiple channels |
| 3 | acquire 100 samples |
| 4 | read a continuous acquisition |
| 5 | read decoded ADC codes |
Connect a valid signal source to the selected AI input and its correct reference. Check the product manual for input range, common-mode limits, grounding and protection. AO output range does not establish AI input limits.
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.
AI Single Read and Read return voltage values only. Single Read Codes and Read Codes return decoded signed I32 samples without host voltage conversion. Code reads and voltage reads consume the same acquisition queue. Raw AI Read returns packet bytes and is not a decoded-code read. AO likewise has separate voltage and decoded-code writes, plus a packet-byte Raw Write.
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.
Run each complete program separately. The examples use explicit handles and status checks, including returned partial read counts and cleanup status.
Read a calibrated AI0 voltage without configuring a stream. Every language supplies handle explicitly and checks status before using the output.
Single Read uses the fixed calibrated 1600 S/s profile with ADC filter settling; this is not a promise of 1600 host calls per second. Simulator samples are zero; real readings depend on the signal.
Single Read returns volts only. Use Single Read Codes for decoded ADC codes. LabVIEW requires regenerated call nodes; no LabVIEW diagram is supplied here.
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, volts = s.read_single_ai(handle, [s.AIChannel.AI0_SE])
if status != 0:
return report(status)
print(f"AI0: {volts[0]:.4f} V")
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 = [
("Stop AI", s.stop_ai(handle)),
("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())
Select AI0 and AI1 in that order. Returned index 0 belongs to AI0 and index 1 to AI1.
Selections are sequential, not simultaneous. Supply 1 to 24 unique logical IDs. SE and DIFF measurements may share physical pins; duplicate logical IDs are invalid.
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):
channels = [s.AIChannel.AI0_SE, s.AIChannel.AI1_SE]
status, volts = s.read_single_ai(handle, channels)
if status != 0:
return report(status)
for channel, voltage in zip(channels, volts):
print(f"{channel.name}: {voltage:.4f} V")
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 = [
("Stop AI", s.stop_ai(handle)),
("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())
Configure a finite total of 100 samples from AI0 with a request of 1000 S/s/channel, then Start and Read.
The current profile table selects 1600 S/s/channel for this request. The nominal duration is 100/1600 = 0.0625 seconds, before startup and transfer overhead.
Read returns volts only. Inspect the returned count even if status indicates an error: complete samples already delivered remain valid. A further read after completion and draining returns +1 with an empty array and zero count.
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, actual_rate = s.configure_ai(handle, [s.AIChannel.AI0_SE], 1000,
s.AcquisitionMode.Finite, total_finite_acquisition_samples_per_channel=100)
if status != 0:
return report(status)
print(f"Nominal rate: {actual_rate:g} S/s/channel")
status = s.start_ai(handle)
if status != 0:
return report(status)
status, volts, count = s.read_ai(handle, 100)
print("Samples returned, including any partial result:", count)
if status not in (0, 1):
return report(status)
if count:
print("First voltage:", volts[0])
status, tail, count = s.read_ai(handle, 1)
print("End status:", status, "remaining samples:", count)
if status != 1:
return report(status if status != 0 else -10)
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 = [
("Stop AI", s.stop_ai(handle)),
("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())
Configure Continuous, Start, and read ten blocks of 100 samples. Cleanup explicitly stops acquisition.
This remains a continuous acquisition even though the application reads a fixed number of blocks. Read regularly: a host-ring overflow is an error, not permission to overwrite unread samples.
Each normal block contains 100 samples per channel. The array length is count times configured channel count. Preserve returned complete samples on a failed read.
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, actual_rate = s.configure_ai(handle, [s.AIChannel.AI0_SE], 1000, s.AcquisitionMode.Continuous)
if status != 0:
return report(status)
print(f"Nominal rate: {actual_rate:g} S/s/channel")
status = s.start_ai(handle)
if status != 0:
return report(status)
for index in range(10):
status, volts, count = s.read_ai(handle, 100)
print("Block", index, "samples:", count)
if status != 0:
return report(status)
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 = [
("Stop AI", s.stop_ai(handle)),
("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())
Use the new Single Read Codes and Read Codes functions. They return signed I32 sample values without host voltage conversion; the values still reflect the ADC calibration applied by firmware.
Single Read Codes invalidates earlier scan configuration, so Configure is called after the single measurement. Configure/Start lifecycle and stream-read count semantics match voltage reads.
Read Codes and voltage Read consume the same acquisition queue. Calling one after the other returns successive samples, not two views of one sample block. Raw Read is a different interface returning firmware packet bytes.
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, single_codes = s.read_single_ai_codes(handle, [s.AIChannel.AI0_SE])
if status != 0:
return report(status)
print("Single ADC code:", single_codes[0])
status, actual_rate = s.configure_ai(handle, [s.AIChannel.AI0_SE], 1000, s.AcquisitionMode.Finite, 100)
if status != 0:
return report(status)
status = s.start_ai(handle)
if status != 0:
return report(status)
status, codes, count = s.read_ai_codes(handle, -1)
print("Decoded samples:", count)
if count:
print("First ADC code:", codes[0])
if status not in (0, 1):
return report(status)
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 = [
("Stop AI", s.stop_ai(handle)),
("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.
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.