DAQiFi Core

Revolutionizing the data collection experience with convenient, portable device connectivity.

The official cross-platform .NET SDK for DAQiFi wireless data acquisition devices.

daqifi.com · DAQiFi Desktop · Report an issue

What is DAQiFi Core?

DAQiFi builds wireless data acquisition hardware designed to get out of the way so you can focus on the data, not the collection process.

DAQiFi Core is how you integrate that hardware into your own .NET applications — custom dashboards, automated test rigs, research pipelines, production-monitoring tools. Discover devices, connect over WiFi or USB, stream samples in real time, configure networks, push firmware updates — all from one async, strongly-typed .NET API.

Prefer a ready-made GUI? Check out DAQiFi Desktop, which is built on top of this library.

Want to drive a device from an AI assistant? The repo also ships an MCP server — point Claude, Cursor, Codex, or any MCP-aware client at it to discover, configure channels, drive digital I/O, PWM and analog outputs, set the sample rate, and run SD-card logging — then list, download, and CSV the recorded data back — through plain conversation.

See it in 30 seconds

dotnet add package Daqifi.Core

using Daqifi.Core.Device;
using Daqifi.Core.Channel;

// Connect — transport and device initialization handled for you.
await using var device = await DaqifiDeviceFactory.ConnectTcpAsync("192.168.1.100", 9760);

// Subscribe to decoded, per-channel samples
var ai0 = device.GetChannelsSnapshot().First(c => c.Type == ChannelType.Analog && c.ChannelNumber == 0);
ai0.SampleReceived += (_, e) => Console.WriteLine($"{e.Sample.Timestamp}: {e.Sample.Value} V");

// Enable channel 0, then stream at 100 Hz
device.EnableChannel(ai0);
device.StreamingFrequency = 100;
device.StartStreaming();

A real, working program — no GUI required. Prefer the raw protobuf frame instead? Subscribe to device.MessageReceived — see Streaming Data.

Common applications

DAQiFi hardware is in the field for work like:

• Research labs — moon regolith testing and similar materials studies
• Medical R&D — prosthetic socket pressure testing
• Industrial monitoring — wireless multi-channel sensing
• Engineering education — SCPI command structure and LabVIEW compatibility
• Test automation — scripted benchtop measurements

More examples at daqifi.com.

Where DAQiFi Core fits

What you can do

Quick recipes

Connection options

Pick whichever transport fits your setup — each snippet is a standalone, copy-paste-ready starting point.

TCP with a resilient retry preset (5 retries, longer timeouts):

await using var device = await DaqifiDeviceFactory.ConnectTcpAsync(
    "192.168.1.100", 9760, DeviceConnectionOptions.Resilient);

Serial / USB:

// Replace with your OS-specific port:
//   Windows: "COM3"   •   macOS: "/dev/cu.usbmodem1"   •   Linux: "/dev/ttyACM0"
await using var device = await DaqifiDeviceFactory.ConnectSerialAsync("COM3");

From a discovered device:

using var finder = new WiFiDeviceFinder();
var devices = await finder.DiscoverAsync(TimeSpan.FromSeconds(5));
await using var device = await DaqifiDeviceFactory.ConnectFromDeviceInfoAsync(devices.First());

Custom retry options

using Daqifi.Core.Communication.Transport;

var options = new DeviceConnectionOptions
{
    DeviceName = "My DAQiFi",
    ConnectionRetry = new ConnectionRetryOptions
    {
        MaxAttempts = 3,
        ConnectionTimeout = TimeSpan.FromSeconds(10)
    },
    InitializeDevice = true
};
await using var device = await DaqifiDeviceFactory.ConnectTcpAsync("192.168.1.100", 9760, options);

Connecting takes control of the device. A DAQiFi unit has a single global acquisition, and the default connect sequence stops it — so connecting to a device another session is already streaming silently ends that session's data. Use DeviceConnectionOptions.Observing for a secondary session that only needs to look, and DaqifiDeviceRegistry to avoid opening the same unit twice in one process. See Connecting stops any stream already running.

Device discovery

using Daqifi.Core.Device.Discovery;

// WiFi — UDP broadcast on port 30303 by default
using var wifiFinder = new WiFiDeviceFinder();
wifiFinder.DeviceDiscovered += (_, e) =>
    Console.WriteLine($"Found: {e.DeviceInfo.Name} at {e.DeviceInfo.IPAddress}");

var wifiDevices = await wifiFinder.DiscoverAsync(TimeSpan.FromSeconds(5));

// USB / Serial
using var serialFinder = new SerialDeviceFinder();
var serialDevices = await serialFinder.DiscoverAsync();

On a home or multi-AP network, browse with mDNS as well. UDP broadcast does not reliably cross an access-point boundary — a device associated to a second AP is online and healthy, yet the broadcast sweep returns nothing — so MDnsDeviceFinder browses the _daqifi._tcp.local. service over multicast instead, which is the traffic consumer routers already reflect across APs, SSIDs and VLANs. It produces the same IDeviceInfo shape, so anything that connects to a broadcast-discovered device connects to an mDNS-discovered one unchanged.

using var mdnsFinder = new MDnsDeviceFinder();
var mdnsDevices = await mdnsFinder.DiscoverAsync(TimeSpan.FromSeconds(5));

Run both — devices on firmware without an mDNS responder are still found over UDP broadcast, so the two paths together cover more networks than either alone:

using var finder = new AllTransportsDeviceFinder(
    [new WiFiDeviceFinder(), new MDnsDeviceFinder(), new SerialDeviceFinder()],
    identitySelector: device => device.SerialNumber);

var devices = await finder.DiscoverAsync(TimeSpan.FromSeconds(5));

The identitySelector is what collapses a board that answers on both network paths into a single entry. Without one, the default per-transport identity prefers the MAC address, which the broadcast reply carries and the mDNS advertisement does not, so the same board is reported twice — as two entries that are both genuinely connectable, but still two.

Two caveats worth knowing: the device must be on firmware that advertises the service (see daqifi-nyquist-firmware#345), and some hardened corporate or guest networks filter multicast entirely — connect by IP address directly when they do.

Need fine-grained control? Pass a CancellationToken or override the discovery port: