By the way, here is an example. This code uses keyboard inputs, UDP packets (only skeleton: actual parser and control logic have not been implemented), and NIDAQ inputs (only the first three AIs are implemented) to control an Agent in Unity. You need to specify the device name and channels in the inspector. This code has been confirmed to work with USB6001 in Unity 6.3.
//AgentController.cs
using UnityEngine;
using UnityEngine.InputSystem;
using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Collections.Generic;
using System.Threading;
using System.Runtime.InteropServices;
using System.Diagnostics;
/// <summary>
/// Threaded Controller managing Keyboard, UDP, and NI-DAQmx Analog Inputs.
/// Background threads handle I/O to keep the main Unity Render/Physics thread smooth.
/// </summary>
public class AgentController : MonoBehaviour
{
[Header("Movement Settings")]
public float moveSpeed = 10f;
public float rotationSpeed = 100f;
[Header("UDP Configuration")]
public bool useUDP = false;
public int udpPort = 11000;
private UdpClient udpClient;
private IPEndPoint remoteEndPoint;
private Thread udpThread;
private string lastUdpMsg = null;
private readonly object udpLock = new object(); // Synchronizes access to UDP string
[Header("NIDAQ Configuration")]
public bool useNIDAQ = false;
[Tooltip("Order: Element 0=X, 1=Y, 2=Z. Supports up to 8 channels.")]
public List<string> physicalChannels = new List<string> { "Dev1/ai0" };
private IntPtr taskHandle = IntPtr.Zero;
private Thread daqThread;
private double[] lastDaqSignals = new double[8]; // Thread-safe buffer for hardware values
private readonly object daqLock = new object(); // Synchronizes access to DAQ array
private int activeChannelCount = 0;
// Master switch to shut down background threads on exit
private bool isRunning = false;
void Start()
{
isRunning = true;
if (useUDP) InitUDPThreaded();
if (useNIDAQ) InitNIDAQThreaded();
}
/// <summary>
/// Starts a background thread to listen for UDP packets.
/// Only the latest packet is kept; older ones are overwritten.
/// </summary>
private void InitUDPThreaded()
{
try
{
udpClient = new UdpClient(udpPort);
remoteEndPoint = new IPEndPoint(IPAddress.Any, 0);
// Fixes a Windows-specific bug where UDP throws an exception if the remote port closes
const int SIO_UDP_CONNRESET = -1744830452;
udpClient.Client.IOControl(SIO_UDP_CONNRESET, new byte[] { 0 }, null);
udpThread = new Thread(() => {
while (isRunning)
{
// Check if data is waiting in the OS buffer
while (udpClient.Available > 0)
{
byte[] data = udpClient.Receive(ref remoteEndPoint);
string msg = Encoding.ASCII.GetString(data);
// Overwrite previous message so Update() only sees the newest data
lock (udpLock) { lastUdpMsg = msg; }
}
//Thread.Sleep(5); // Supposed to be 5ms, but in reality it is close to 15ms because of OS overhead.
Stopwatch sw = Stopwatch.StartNew();
while (sw.Elapsed.TotalMilliseconds < 5)
{
// "Spin" until time has passed -> Uses the CPU more but precise.
}
}
});
udpThread.IsBackground = true;
udpThread.Start();
}
catch (Exception e) { UnityEngine.Debug.LogError($"UDP Thread Init Failed: {e.Message}"); }
}
/// <summary>
/// Initializes NI-DAQmx via P/Invoke and starts a hardware polling thread.
/// </summary>
private void InitNIDAQThreaded()
{
if (physicalChannels == null || physicalChannels.Count == 0) return;
activeChannelCount = Mathf.Min(physicalChannels.Count, 8);
try
{
string config = string.Join(", ", physicalChannels.ToArray());
// Create and configure the hardware task
NINative.DAQmxCreateTask("AgentTask", out taskHandle);
NINative.DAQmxCreateAIVoltageChan(taskHandle, config, "", -1, -10.0, 10.0, 10348, null);
NINative.DAQmxStartTask(taskHandle);
daqThread = new Thread(() => {
double[] buffer = new double[activeChannelCount];
while (isRunning)
{
int read;
// Poll 1 sample per channel. Timeout 0.1s to allow thread to exit quickly.
int err = NINative.DAQmxReadAnalogF64(taskHandle, 1, 0.1, 0, buffer, (uint)activeChannelCount, out read, IntPtr.Zero);
if (err == 0 && read > 0)
{
lock (daqLock) { Array.Copy(buffer, lastDaqSignals, activeChannelCount); }
}
//Thread.Sleep(1); // Supposed to be 5ms, but in reality it is close to 15ms because of OS overhead.
Stopwatch sw = Stopwatch.StartNew();
while (sw.Elapsed.TotalMilliseconds < 5)
{
// "Spin" until time has passed -> Uses the CPU more but precise.
}
}
});
daqThread.IsBackground = true;
daqThread.Start();
UnityEngine.Debug.Log($"NIDAQ Thread Started for: {config}");
}
catch (Exception e) { UnityEngine.Debug.LogError($"NIDAQ Thread Init Failed: {e.Message}"); }
}
void Update()
{
Vector3 moveInput = Vector3.zero;
Vector3 rotInput = Vector3.zero;
Keyboard kb = Keyboard.current;
// 1. Capture Keyboard Input (Additive)
if (kb != null)
{
moveInput += GetKeyboardMovement(kb);
rotInput += GetKeyboardRotation(kb);
}
// 2. Capture UDP Input (Most recent only)
lock (udpLock)
{
if (lastUdpMsg != null)
{
moveInput += ParseUDP(lastUdpMsg);
lastUdpMsg = null; // Mark as "consumed" so we don't process it twice
}
}
// 3. Capture NIDAQ Input (Thread-safe copy)
if (useNIDAQ)
{
double[] sigs = new double[8];
lock (daqLock) { Array.Copy(lastDaqSignals, sigs, 8); }
moveInput += MapDaqToMovement(sigs);
//rotInput += MapDaqToMovement(sigs); // needs to be implemented
}
// 4. Move Agent
transform.Translate(moveInput * moveSpeed * Time.deltaTime, Space.Self);
transform.Rotate(rotInput * rotationSpeed * Time.deltaTime);
}
private Vector3 GetKeyboardMovement(Keyboard kb)
{
float x = 0, y = 0, z = 0;
if (kb.wKey.isPressed) z += 1; if (kb.sKey.isPressed) z -= 1;
if (kb.aKey.isPressed) x -= 1; if (kb.dKey.isPressed) x += 1;
if (kb.eKey.isPressed) y += 1; if (kb.qKey.isPressed) y -= 1;
return new Vector3(x, y, z);
}
private Vector3 GetKeyboardRotation(Keyboard kb)
{
float p = 0, y = 0, r = 0;
if (kb.jKey.isPressed) y -= 1; if (kb.lKey.isPressed) y += 1;
if (kb.iKey.isPressed) p -= 1; if (kb.kKey.isPressed) p += 1;
if (kb.uKey.isPressed) r += 1; if (kb.oKey.isPressed) r -= 1;
return new Vector3(p, y, r);
}
private Vector3 MapDaqToMovement(double[] signals)
{
// Maps list elements to axes: Index 0=X, 1=Y, 2=Z
float x = (activeChannelCount > 0) ? (float)signals[0] : 0;
float y = (activeChannelCount > 1) ? (float)signals[1] : 0;
float z = (activeChannelCount > 2) ? (float)signals[2] : 0;
return new Vector3(x, y, z);
}
private Vector3 ParseUDP(string msg)
{
// Example: Assume message is forward-only. Replace with your custom parser.
return Vector3.forward;
}
void OnApplicationQuit()
{
isRunning = false; // Flag background threads to stop loops
// Cleanup NI-DAQmx Task
if (taskHandle != IntPtr.Zero)
{
NINative.DAQmxStopTask(taskHandle);
NINative.DAQmxClearTask(taskHandle);
}
// Close UDP Socket
if (udpClient != null) udpClient.Close();
// Give threads time to finish clean shutdown
if (daqThread != null) daqThread.Join(200);
if (udpThread != null) udpThread.Join(200);
}
}
/// <summary>
/// Static Native P/Invoke wrapper for the National Instruments nicaiu.dll driver.
/// </summary>
public static class NINative
{
private const string dllName = "nicaiu.dll";
[DllImport(dllName)]
public static extern int DAQmxCreateTask(string taskName, out IntPtr taskHandle);
[DllImport(dllName)]
public static extern int DAQmxCreateAIVoltageChan(IntPtr taskHandle, string physicalChannel, string nameToAssignToChannel, int terminalConfig, double minVal, double maxVal, int units, string customScaleName);
[DllImport(dllName)]
public static extern int DAQmxStartTask(IntPtr taskHandle);
[DllImport(dllName)]
public static extern int DAQmxReadAnalogF64(IntPtr taskHandle, int numSampsPerChan, double timeout, uint fillMode, double[] readArray, uint arraySizeInSamps, out int sampsPerChanRead, IntPtr reserved);
[DllImport(dllName)]
public static extern int DAQmxStopTask(IntPtr taskHandle);
[DllImport(dllName)]
public static extern int DAQmxClearTask(IntPtr taskHandle);
}
