Daqifi.Core 0.22.0

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.

See it in 30 seconds

dotnet add package Daqifi.Core

using Daqifi.Core.Device;
using Daqifi.Core.Communication.Producers;

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

// Subscribe to incoming samples
device.MessageReceived += (_, e) =>
{
    if (e.Message.Data is DaqifiOutMessage msg)
        Console.WriteLine($"{msg.MsgTimeStamp}: {string.Join(", ", msg.AnalogInData)}");
};

// Enable analog channels via bitmask (0b11 = first 2 channels), then stream at 100 Hz
device.Send(ScpiMessageProducer.EnableAdcChannels("3"));
device.Send(ScpiMessageProducer.StartStreaming(100));

A real, working program — no GUI required.

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):

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"
using var device = await DaqifiDeviceFactory.ConnectSerialAsync("COM3");

From a discovered device:

using var finder = new WiFiDeviceFinder();
var devices = await finder.DiscoverAsync(TimeSpan.FromSeconds(5));
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
};
using var device = await DaqifiDeviceFactory.ConnectTcpAsync("192.168.1.100", 9760, options);

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();

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

using var cts = new CancellationTokenSource();
cts.CancelAfter(TimeSpan.FromSeconds(10));
var devices = await wifiFinder.DiscoverAsync(cts.Token);

using var customFinder = new WiFiDeviceFinder(discoveryPort: 12345);

Network configuration

Devices implementing INetworkConfigurable accept programmatic WiFi and LAN configuration. Mode, Ssid, and Password are always applied on every call; only StaticIP, SubnetMask, and Gateway honor null as "leave unchanged" — so DHCP-only callers can omit the static-IP fields without affecting their DHCP setup.

using System.Net;
using Daqifi.Core.Device.Network;

if (device is INetworkConfigurable networkDevice)
{
    var config = new NetworkConfiguration
    {
        Ssid       = "MyNetwork",
        Password   = "secret",
        Mode       = WifiMode.ExistingNetwork,
        StaticIP   = IPAddress.Parse("192.168.1.42"),
        SubnetMask = IPAddress.Parse("255.255.255.0"),
        Gateway    = IPAddress.Parse("192.168.1.1"),
    };
    await networkDevice.UpdateNetworkConfigurationAsync(config);
}

Firmware updates

IFirmwareUpdateService orchestrates both PIC32 and WiFi-module flashing with explicit state transitions and IProgress<FirmwareUpdateProgress> for UI / CLI reporting.

• UpdateFirmwareAsync(...) — PIC32 firmware flashing from a local Intel HEX file
• UpdateWifiModuleAsync(...) — WiFi module flashing via an external tool runner. Automatically checks the device's current WiFi-chip firmware against the latest GitHub release and skips the flash if already up to date.

Note: The default WiFi flash tool config uses winc_flash_tool.cmd conventions. On macOS / Linux, supply a compatible executable and argument template via FirmwareUpdateServiceOptions.

Supported devices

Both are auto-detected by part number during discovery.

Don't have one yet? See the DAQiFi lineup →

Connection types

• WiFi — discovered via UDP broadcast (port 30303)
• Serial — USB-connected, enumerated as serial ports
• HID — used during firmware updates (HidSharp backend)

Requirements

• .NET 9.0 or .NET 10.0 on Windows, macOS, or Linux
• WiFi discovery: UDP port 30303 reachable (firewall may need configuring; admin may be required on Windows)
• Serial discovery: appropriate USB drivers for your platform

Community & support

• Open an issue for bugs or feature requests
• Reach the team via daqifi.com for commercial integrations and custom hardware needs

For maintainers

This library follows semantic versioning. Releases are automated via GitHub Actions:

1. Create a new GitHub Release
2. Tag it vX.Y.Z (pre-releases use -alpha.1, -beta.1, -rc.1 suffixes)
3. Publishing to NuGet happens automatically on release

<p align="center"> Built by <a href="https://daqifi.com">DAQiFi</a> · Licensed under <a href="LICENSE">MIT</a> </p>