major-ai-skills
Version:
Installable agentic skills / AI agent skills (SKILL.md) for Claude Code, Cursor, Codex CLI, Gemini CLI & Antigravity - 402+ professional app, token-efficiency, and common-sense skills. SEO/GEO ready.
163 lines (127 loc) • 9.01 kB
Markdown
name: labview
description: "Automate LabVIEW dataflow and build workflows, integrate NI-DAQmx or VISA instruments, and diagnose hardware communication."
category: scientific
risk: safe
source: self
source_type: self
date_added: "2026-08-26"
tags: ["labview", "ni-daqmx", "g-language", "producer-consumer-qmh", "visa-scpi", "g-cli", "data-acquisition", "claude"]
tools: ["claude", "cursor", "gemini", "codex"]
# NI LabVIEW Graphical Dataflow & DAQ AI Skill Guide (Claude)
## Overview & Engine Architecture
National Instruments (NI) LabVIEW is a graphical dataflow programming environment (G-Language) engineered for automated test, laboratory instrumentation, industrial data acquisition (DAQ), and real-time FPGA control (CompactRIO / PXI). The platform couples a visual **Front Panel UI** with an asynchronous **Block Diagram Execution Engine**, utilizing design patterns like the **Producer-Consumer Queued Message Handler (QMH)**. LabVIEW integrates natively with **NI-DAQmx**, **NI-VISA (SCPI standard)**, and executes headless continuous integration builds via the **LabVIEW CLI (`LabVIEWCLI.exe`)** and **`g-cli`**. Claude operates as a Principal Test & Measurement Systems Architect and Automated Test Engineer, specializing in **DAQmx high-speed streaming**, **Producer-Consumer thread safety**, **VISA instrument automation (`pyvisa`)**, and **headless VI build scripting**.
### LabVIEW G-Dataflow Engine & Hardware Architecture
```
┌─────────────────────────────────────────────────────────────┐
│ NI LabVIEW Architecture │
│ │
│ Presentation & Design Pattern Tier │
│ ├── Front Panel UI Controls & Waveform Graphs │
│ ├── Block Diagram G-Dataflow Engine (Wires, Nodes, Tunnels)│
│ └── Queued Message Handler (QMH: Producer & Consumer Loops)│
│ │
│ Hardware Driver & Instrument Communication │
│ ├── NI-DAQmx Hardware Subsystem (Analog, Digital, Counters)│
│ ├── NI-VISA Standard (GPIB, USB-TMC, RS-232, TCP-IP SCPI) │
│ └── Real-Time & FPGA Modules (CompactRIO / PXI Targets) │
│ │
│ Automation & CI/CD Tooling Core │
│ ├── LabVIEW CLI (`LabVIEWCLI.exe -OperationName RunVI`) │
│ ├── `g-cli` Open-Source Command Line Interface │
│ └── VI Package Manager (VIPM Community Toolkits) │
└─────────────────────────────────────────────────────────────┘
```
## Operational Capabilities & Agent Directives
1. **NI-DAQmx Python Hardware Automation**: Author Python scripts using the `nidaqmx` API to configure multi-channel hardware tasks, establish continuous sample clocks, and stream voltage data without buffer overruns.
2. **Producer-Consumer QMH Architecture Triage**: Refactor race-prone G-code architectures using thread-safe Queue primitives to isolate high-speed acquisition from disk logging and UI rendering.
3. **VISA SCPI Instrument Scripting (`pyvisa`)**: Build robust instrument communication scripts enforcing correct termination characters (`\n` / `0x0A`) and timeout parameters.
4. **Headless `g-cli` Continuous Integration**: Construct automated CI/CD pipelines executing unit tests (`VI Tester`), building VIPM packages, and generating standalone executables (`.exe`).
## Production Python Automation: Continuous High-Speed DAQmx Streamer (`nidaqmx`)
Save this script as `daqmx_continuous_stream.py` (requires `pip install nidaqmx numpy` and connected NI-DAQ hardware):
```python
"""
NI-DAQmx Continuous Analog Input Streaming Client
Streams multi-channel analog voltage data (ai0, ai1) using hardware sample clocking and circular buffers.
"""
import sys
import time
import numpy as np
import nidaqmx
from nidaqmx.constants import AcquisitionType, TerminalConfiguration
DEVICE_NAME = "Dev1"
SAMPLE_RATE = 10000.0 # 10 kHz
SAMPLES_PER_CHANNEL = 1000 # Read 1000 samples (100ms chunk) per loop iteration
def continuous_daq_acquisition():
print(f"--- [INITIALIZING NI-DAQMX CONTINUOUS ACQUISITION: {DEVICE_NAME}] ---")
try:
with nidaqmx.Task() as task:
# 1. Add Analog Input Voltage Channels (Differential Mode)
task.ai_channels.add_ai_voltage_chan(
f"{DEVICE_NAME}/ai0",
name_to_assign_to_channel="Ch0_Pressure",
terminal_config=TerminalConfiguration.DIFF,
min_val=-10.0,
max_val=10.0
)
task.ai_channels.add_ai_voltage_chan(
f"{DEVICE_NAME}/ai1",
name_to_assign_to_channel="Ch1_Temperature",
terminal_config=TerminalConfiguration.DIFF,
min_val=-10.0,
max_val=10.0
)
# 2. Configure Hardware Sample Clock & Continuous Mode
task.timing.cfg_samp_clk_timing(
rate=SAMPLE_RATE,
sample_mode=AcquisitionType.CONTINUOUS,
samps_per_chan=SAMPLES_PER_CHANNEL * 10 # Circular buffer capacity
)
print(f"• Sample Rate: {SAMPLE_RATE} Hz")
print(f"• Chunk Size: {SAMPLES_PER_CHANNEL} samples per channel")
print("Starting acquisition loop (Press Ctrl+C to stop)...\n")
task.start()
iteration = 0
while iteration < 10: # Collect 10 chunks (1 second total)
# 3. Read Stream Data from Onboard Buffer
data = task.read(number_of_samples_per_channel=SAMPLES_PER_CHANNEL, timeout=2.0)
data_np = np.array(data)
# Calculate RMS / Peak-to-Peak Metrics
ch0_mean = np.mean(data_np[0])
ch1_mean = np.mean(data_np[1])
iteration += 1
print(f"• Chunk #{iteration:>2}: Ch0 Avg = {ch0_mean:>+7.3f} V | Ch1 Avg = {ch1_mean:>+7.3f} V")
print("\n✅ Acquisition sequence completed successfully.")
except nidaqmx.errors.DaqError as e:
print(f"🚨 DAQmx Error [{e.error_code}]: {e.error_description}")
if __name__ == "__main__":
continuous_daq_acquisition()
```
## Technical Troubleshooting Matrix
| Issue & Failure Signature | Root Cause Analysis | Diagnostic & Resolution Pathway |
| :--- | :--- | :--- |
| **DAQmx Error -200279 (Buffer Overflow)** | Acquisition loop processing time exceeds sample interval, filling circular onboard FIFO buffer. | 1. Increase buffer size: `task.timing.cfg_samp_clk_timing(..., samps_per_chan=100000)`.<br>2. Move heavy disk I/O / UI operations to a separate Consumer loop via Queues. |
| **Broken Run Arrow on Block Diagram** | Type mismatch between wired data types (e.g. 1D Array wired into Scalar Double terminal). | Click the broken Run Arrow to open the **Error List** window $\rightarrow$ Double-click error to jump to broken wire terminal. |
| **VISA Error `-1073807343` (`VI_ERROR_TMO`)** | Connected instrument did not receive expected line termination character (e.g. `\n`) or timeout exceeded. | 1. In VISA Configure Serial Port, enable **Termination Character** (`0x0A` / `\n`).<br>2. Increase VISA timeout from $2000\text{ms}$ to $5000\text{ms}$. |
| **Race Conditions / Intermittent Data Glitches** | Multiple parallel execution loops writing to the same Global Variable without synchronization. | Replace Global Variables with a **Functional Global Variable (FGV)** (Uninitialized Shift Register in a While Loop) or thread-safe Queues. |
## Command Line Syntax & `g-cli` Recipes
```bash
# 1. Run LabVIEW VI via LabVIEWCLI
LabVIEWCLI.exe -OperationName RunVI -VIPath "C:\Automation\RunTestSequence.vi"
# 2. Execute Headless VI Build via g-cli
g-cli -- "C:\Automation\BuildApplication.vi" -- "C:\Projects\TestEngine.lvproj"
# 3. Query Connected NI DAQ Hardware via NI-MAX CLI
nisysapi -devices
```
### Essential File Locations
- **LabVIEW Configuration**: `C:\Program Files\National Instruments\LabVIEW 2024\labview.ini`
- **Data Root**: `%USERPROFILE%\Documents\LabVIEW Data\`
- **VI Package Manager Cache**: `C:\ProgramData\JKI\VIPM\`
## Agent Operational Directive
> **MANDATORY**: For continuous high-speed DAQ acquisition, always implement the Producer-Consumer pattern with G-Queues to decouple real-time hardware buffer reads from disk writes and front-panel chart rendering.