# NI-DAQmx

> Hardware di acquisizione dati di National Instruments (telai cDAQ e i loro moduli, dispositivi USB e PCI Express, e i dispositivi simulati di NI MAX) letto un campione per lettura tramite il NI-DAQmx installato su questo computer: la scheda Dispositivo NI-DAQmx, il canale fisico e la misura di un tag, lettura e scrittura, il rilevamento e un esempio completo su un telaio cDAQ.

Il driver **NI-DAQmx** legge e scrive l'hardware di acquisizione dati di National Instruments: i
telai cDAQ e i loro moduli della Serie C, i dispositivi USB come l'USB-6001 o l'USB-6211, e i
dispositivi PCI Express, tramite NI-DAQmx, il driver che National Instruments distribuisce
gratuitamente per il proprio hardware. È l'hardware che un programma LabVIEW legge con i blocchi
DAQmx, configurato su un pannello invece che cablato in uno schema a blocchi: ogni tag è un canale
fisico, come lo chiama NI MAX (`ai0`, `port0/line3`, `ao0`, `ctr0`), con ciò che il canale misura o
pilota, e i suoi valori arrivano dove arrivano quelli di ogni altro tag: nella Logica, sulle
dashboard, nelle esecuzioni di un banco di prova del [Process](process).

Il driver legge un campione per lettura: all'intervallo di interrogazione di ogni tag prende un
valore del canale, come fa ogni altro driver. Serve i segnali lenti (temperature, pressioni,
livelli, stati, conteggi), non l'acquisizione continua che l'hardware fa con il proprio clock; vedi
[Limiti da conoscere](#limits-worth-knowing).

Un dispositivo di questo driver è un dispositivo di NI MAX, trovato con il nome che NI MAX gli dà,
ovunque sia collegato: in USB, in uno slot PCI Express, in un telaio cDAQ in USB o Ethernet. I
dispositivi simulati che NI MAX crea gratuitamente, per la maggior parte dell'hardware NI, vengono
letti come quelli reali, quindi una configurazione si può costruire e provare prima che l'hardware
arrivi. I dispositivi simulati si possono creare anche tramite l'API di configurazione di NI, che un
assistente IA con accesso a questo computer può usare se lo si autorizza. I dispositivi stanno sotto il
driver e si possono archiviare in cartelle,
**Driver → Cartella → Dispositivo → Tag**, come sotto ogni driver senza linea seriale né broker.

## NI-DAQmx su questo computer {#ni-daqmx-on-this-computer}

Il prodotto non include NI-DAQmx e non installa nessuno dei suoi file. Il driver legge l'hardware
tramite il NI-DAQmx installato su questo computer, lo stesso che usano NI MAX e LabVIEW. La stazione
controlla da sé se c'è: la prima volta che lo chiedono la pagina del driver, la pagina di uno dei
suoi dispositivi o l'agente, e di nuovo ogni 30 secondi finché manca. Finché il Connector non è
partito non si sa se NI-DAQmx c'è, e non se ne dice nulla. Finché manca:

| Dove | Che cosa succede |
| --- | --- |
| La pagina del driver | Un avviso di attenzione, « NI-DAQmx non è installato su questo computer », con i passaggi qui sotto. Il suo link apre la pagina di NI nel browser del computer. |
| La pagina di ogni dispositivo | Lo stesso avviso. |
| I dispositivi | Si possono aggiungere e configurare, tag compresi; restano offline, e l'ultimo errore di ciascuno dà gli stessi passaggi, in inglese, come sono scritte le cause proprie del driver. |
| Rileva | Non elenca nulla, e dice che NI-DAQmx non è installato e che l'avviso nella pagina del driver indica il download e i passaggi di installazione. |
| L'agente | `driver_capabilities` dà i passaggi sotto `prerequisite`, con `installed` a false. |

Per installarlo:

1. Aprire la pagina di NI [NI-DAQ™mx Download](https://www.ni.com/en/support/downloads/drivers/download.ni-daq-mx.html). Chiede di accedere con un account NI prima del download.
2. Nel suo elenco Version, prendere la versione più recente il cui readme (**View Readme**) elenca il Windows di questo computer e, sotto Device Support, il dispositivo. NI-DAQmx funziona solo su Windows a 64 bit.
3. Eseguire il programma di installazione come amministratore: installa NI-DAQmx tramite NI Package Manager. Riavviare il computer se il programma di installazione lo chiede.

Il NI-DAQmx più recente non supporta più alcuni dispositivi meno recenti: se il suo readme non
elenca il dispositivo, scegliere nell'elenco Version una versione precedente il cui readme lo
elenca.

Entro 30 secondi dall'installazione l'avviso scompare e i dispositivi di questo driver si collegano
con la configurazione che hanno, senza riavviare Ganter Lab. NI MAX (NI Measurement & Automation
Explorer) mostra ogni dispositivo con il nome da inserire nella [scheda Dispositivo NI-DAQmx](#the-ni-daqmx-device-card).

## La pagina del driver {#the-drivers-page}

La pagina porta la tabella **Dispositivi** di ogni driver (vedi
[La tabella dei dispositivi](connector-drivers#the-device-table)), che cresce con
**Aggiungi dispositivo**, a destra del suo titolo; vuota, dice « Nessun dispositivo. » La barra del
driver porta **Rileva**, e la pagina non ha la scheda Ambito della scansione, perché la scansione
interroga NI-DAQmx e nient'altro.

## Dispositivo {#device}

### La scheda Dispositivo NI-DAQmx {#the-ni-daqmx-device-card}

Un dispositivo di questo driver non ha la scheda Connessione: non ci sono host, porta né percorso da
scrivere, perché NI-DAQmx trova il dispositivo per nome. Al suo posto, la scheda
**Dispositivo NI-DAQmx** dice quale dispositivo di NI MAX legge.

| Campo | Significato | Predefinito |
| --- | --- | --- |
| **Nome del dispositivo** | « Il nome che NI MAX dà al dispositivo, ad esempio Dev1, o cDAQ1Mod1 per un modulo di un telaio cDAQ. Un dispositivo rinominato in NI MAX torna a essere letto appena il suo nuovo nome viene scritto qui. » | vuoto |
| **Prodotto** | Sola lettura: « Ciò che NI-DAQmx dice che è il dispositivo, ad esempio NI 9211, letto ogni volta che la stazione vi si connette. » Dice « Non ancora letto » finché il dispositivo non si connette, e di nuovo quando non è più connesso. Non se ne salva nulla. | |

Un telaio cDAQ è un dispositivo di NI MAX a sé (`cDAQ1`), e lo è anche ciascuno dei suoi moduli
(`cDAQ1Mod1`, `cDAQ1Mod2`). I canali di un modulo si leggono sul dispositivo del modulo; i
contatori del telaio (da `_ctr0` a `_ctr3`), sul dispositivo del telaio.
L'**Intervallo di interrogazione (ms)** della scheda Dispositivo funziona come per ogni driver, e
ogni tag può sostituirlo.

Un dispositivo nuovo non ha ancora un nome, e la stazione non prova a raggiungerlo finché non ne ha
uno: la sua riga dice « Dispositivo NI-DAQmx non ancora inserito », i suoi tag si leggono come vuoti,
e la sua pagina porta l'avviso
« La stazione non prova a raggiungere questo dispositivo finché non ha il nome di un dispositivo NI-DAQmx, quindi non ne viene ancora letto nulla e non c'è alcun errore da mostrare. Inserire il nome che NI MAX dà al dispositivo nella scheda Dispositivo NI-DAQmx qui sotto e la stazione vi si connette. »
Su un computer senza NI-DAQmx, al suo posto compare l'avviso che NI-DAQmx non è installato.

Un nome che NI-DAQmx non potrebbe mai leggere viene rifiutato sotto la casella: « Un nome di dispositivo non contiene '/', ',' o ':'. Scrivere il nome esattamente come lo mostra NI MAX, ad esempio Dev1 o cDAQ1Mod1. »
Una barra è ciò che separa un dispositivo dal suo canale, quindi `Dev1/ai0` è il canale di un tag e
non un dispositivo. Se NI MAX conosce il nome è la risposta di NI-DAQmx stesso, data quando la
stazione si connette: un dispositivo che NI MAX non conosce resta offline con le parole di NI-DAQmx
come ultimo errore.

L'URI di base che l'intestazione mostra è il nome del dispositivo dietro lo schema del driver:
`nidaqmx://cDAQ1Mod1`. Due dispositivi di questo driver possono leggere lo stesso dispositivo di NI
MAX, per esempio lo stesso modulo con due intervalli di interrogazione diversi; il nome non deve
essere univoco.

## Indirizzamento del tag {#tag-addressing}

### Il canale fisico {#the-physical-channel}

Un tag di questo driver legge o pilota un canale del suo dispositivo. La scheda Sorgente del tag
porta la casella **Canale fisico**, con sotto un suggerimento che segue la misura:
« Canale di ingresso analogico, ad es. ai0 o cDAQ1Mod1/ai0 », « Linea digitale, ad es. port0/line3 o Dev1/port0/line3 »,
« Canale di uscita analogico, ad es. ao0 o Dev1/ao0 » o « Contatore, ad es. ctr0, o _ctr0 su un telaio cDAQ ».

Il canale viene salvato relativo al suo dispositivo (`ai0`), quindi un dispositivo rinominato in NI
MAX cambia un solo campo, quello del dispositivo. Un canale scritto per intero come lo scrive NI MAX
(`cDAQ1Mod1/ai0`) viene salvato relativo quando nomina il dispositivo stesso del tag, e rifiutato
quando ne nomina un altro:
« Questo canale appartiene al dispositivo Dev1, non a cDAQ1Mod1. Scrivere un canale di questo dispositivo, oppure solo il canale, ad esempio ai0. »

### Misure {#measurements}

Sotto il canale, **Misura** dice che cosa il canale misura o pilota. La misura decide i tipi di dato
con cui il tag viene letto, l'accesso che consente, la sua unità e i campi disegnati sotto.

| Misura | Canale | Tipo di dato | Accesso | Unità |
| --- | --- | --- | --- | --- |
| **Ingresso in tensione** | un ingresso analogico, `ai0` | Double o Float | Sola lettura | volt |
| **Ingresso in corrente** | un ingresso analogico, `ai0` | Double o Float | Sola lettura | milliampere |
| **Termocoppia** | un ingresso analogico, `ai0` | Double o Float | Sola lettura | gradi Celsius |
| **Linea di ingresso digitale** | una linea digitale, `port0/line3` | Boolean | Sola lettura | |
| **Linea di uscita digitale** | una linea digitale, `port0/line3` | Boolean | Lettura e scrittura (predefinito), Sola scrittura o Sola lettura | |
| **Uscita in tensione** | un'uscita analogica, `ao0` | Double o Float | Sola scrittura | volt |
| **Conteggio dei fronti** | un contatore, `ctr0` (`_ctr0` su un telaio cDAQ) | Int64 o Double | Sola lettura | conteggi |

Un tag nuovo è un ingresso in tensione, letto come Double. Un canale scritto che la misura in vigore
non legge porta la misura che legge più naturalmente: un ingresso analogico, un ingresso in tensione;
una linea digitale, una linea di ingresso digitale; un'uscita analogica, un'uscita in tensione; e un
contatore, un conteggio dei fronti. Scegliere un'altra misura porta il campo di quella misura, e un
tipo di dato o un accesso che non consente diventa quello che usa, quindi gli elenchi Tipo di dato e
Accesso offrono solo ciò che la misura consente. La corrente si legge in milliampere (NI-DAQmx legge
ampere e il driver moltiplica per 1000), quindi un anello 4-20 mA si scrive come lo si dice.

Ogni misura dice sotto il suo selettore che cosa fa:

| Misura | La riga sotto |
| --- | --- |
| **Ingresso in tensione** | « Legge un campione in volt a ogni lettura. » |
| **Ingresso in corrente** | « Legge un campione in milliampere a ogni lettura. » |
| **Termocoppia** | « Legge un campione in gradi Celsius a ogni lettura, con il giunto freddo compensato. » |
| **Linea di ingresso digitale** | « Legge la linea come vero (alto) o falso (basso). » |
| **Linea di uscita digitale** | « Porta la linea al valore scritto e rilegge lo stato che mantiene. » |
| **Uscita in tensione** | « Porta l'uscita alla tensione scritta. NI-DAQmx non rilegge un'uscita analogica, quindi il tag è di sola scrittura. » |
| **Conteggio dei fronti** | « Conta i fronti dal momento in cui la stazione si connette al dispositivo e legge il conteggio a ogni lettura. Una riconnessione riparte dal conteggio iniziale. » |

### I campi della misura {#the-measurements-fields}

Un campo che la misura non legge non viene disegnato né salvato con il tag.

| Campo | Misure | Significato | Predefinito |
| --- | --- | --- | --- |
| **Campo (V)**, **Campo (mA)** o **Campo (°C)** | Ingresso in tensione, Ingresso in corrente, Termocoppia, Uscita in tensione | Due caselle, **Minimo** e **Massimo**, nell'unità della misura. Su un ingresso: « NI-DAQmx sceglie il campo di ingresso del dispositivo che contiene questo, quindi un campo stretto legge un segnale piccolo con più finezza. » Sull'uscita in tensione: « L'uscita accetta solo valori in questo campo; una scrittura fuori campo viene rifiutata prima di raggiungere il dispositivo. » | da -10 a 10 V; da 0 a 20 mA; da 0 a 100 °C |
| **Configurazione dei terminali** | Ingresso in tensione, Ingresso in corrente | **Predefinita del canale**, **Differenziale**, **Single-ended riferita (RSE)**, **Single-ended non riferita (NRSE)** o **Pseudodifferenziale**: « Come è cablato l'ingresso: un ingresso differenziale misura tra due terminali del canale, uno single-ended rispetto a un riferimento comune. La predefinita del canale è quella che NI-DAQmx sceglie per questo canale. » | **Predefinita del canale** |
| **Resistenza di shunt** | Ingresso in corrente | **Predefinita del canale**, **Interna** o **Esterna**: « La resistenza che la corrente attraversa per essere misurata: quella integrata nel dispositivo, o una esterna collegata sull'ingresso, con il suo valore scritto qui. » | **Predefinita del canale** |
| **Valore dello shunt (Ω)** | Ingresso in corrente, con la resistenza di shunt **Esterna** | Il valore della resistenza esterna, in ohm. | 249 |
| **Tipo di termocoppia** | Termocoppia | **Tipo J**, **Tipo K**, **Tipo N**, **Tipo R**, **Tipo S**, **Tipo T**, **Tipo B** o **Tipo E**. | **Tipo K** |
| **Compensazione del giunto freddo (CJC)** | Termocoppia | **Sensore integrato** o **Temperatura fissa**: « La temperatura del giunto freddo della termocoppia: misurata dal sensore integrato nel dispositivo o nella sua morsettiera, oppure una temperatura fissa scritta qui quando il giunto è mantenuto a una temperatura nota. » | **Sensore integrato** |
| **Temperatura CJC (°C)** | Termocoppia, con **Temperatura fissa** | La temperatura del giunto freddo, in gradi Celsius. | 25 |
| **Fronte contato** | Conteggio dei fronti | **Fronte di salita** o **Fronte di discesa**. | **Fronte di salita** |
| **Direzione del conteggio** | Conteggio dei fronti | **Conteggio crescente** o **Conteggio decrescente**. | **Conteggio crescente** |
| **Conteggio iniziale** | Conteggio dei fronti | Il conteggio da cui il contatore parte ogni volta che il dispositivo si connette, da 0 a 4294967295. | 0 |
| **Terminale di ingresso** | Conteggio dei fronti | « Il terminale i cui impulsi vengono contati, ad esempio /Dev1/PFI8. Se lasciato vuoto, il contatore conta sul proprio terminale di ingresso predefinito. » Vuota, la casella dice « Predefinito del contatore ». Un terminale scritto senza il suo dispositivo (`PFI8`) si legge sul dispositivo stesso del tag. Su un contatore di un telaio cDAQ (`_ctr0`), che non ha un terminale di ingresso proprio, la casella non indica alcun predefinito e la nota dice « Il terminale i cui impulsi vengono contati, ad esempio /cDAQ1Mod2/PFI0. Un contatore di un telaio cDAQ non ha un terminale di ingresso proprio, quindi questo è obbligatorio. » | vuoto |

Un tag i cui campi non possono funzionare non viene salvato, e la pagina del tag dice che cosa gli
manca:

| Inserisci | La pagina del tag dice |
| --- | --- |
| Nessun canale | « Scrivere il canale fisico, ad esempio ai0 o Dev1/ai0. » |
| Un canale di un altro tipo rispetto a quello che la misura legge, come `ao0` sotto una termocoppia | « Questa misura legge un canale di ingresso analogico, ad esempio ai0. », « Un'uscita in tensione pilota un canale di uscita analogico, ad esempio ao0. », « Una linea digitale si scrive come porta e linea, ad esempio port0/line3. » o « Un conteggio dei fronti legge un contatore, ad esempio ctr0. » |
| Un minimo che non sta sotto il massimo | « Il minimo deve essere inferiore al massimo. » |
| Uno shunt esterno senza una resistenza maggiore di zero | « Uno shunt esterno ha bisogno della sua resistenza in ohm, maggiore di zero. » |
| Una temperatura fissa del giunto freddo pari o inferiore allo zero assoluto | « La temperatura CJC deve essere una temperatura in gradi Celsius sopra lo zero assoluto. » |
| Un conteggio iniziale fuori da ciò che un contatore a 32 bit contiene | « Il conteggio iniziale è un numero intero da 0 a 4294967295. » |
| Un terminale di ingresso con spazi o virgole | « Scrivere il terminale di ingresso come lo chiama NI-DAQmx, ad esempio /Dev1/PFI8, senza spazi né virgole. » |
| Un conteggio dei fronti su un contatore di un telaio cDAQ (`_ctr0`) senza terminale di ingresso | « Un contatore di un telaio cDAQ non ha un terminale di ingresso proprio: scrivere il terminale su cui arrivano i suoi impulsi, ad esempio /cDAQ1Mod2/PFI0. » |
| Un tipo di dato o un accesso che la misura non consente | « Questa misura si legge come Double, Float. », e per un accesso, la frase che nomina gli accessi che la misura consente |

Il salvataggio tiene le stesse regole dei pannelli, e il registro delle azioni lo dice quando ne
rifiuta uno:
« Il dispositivo 'Module voltages' nomina un dispositivo NI-DAQmx che il driver non può leggere. Aprirlo e correggere il nome del dispositivo che il suo pannello segnala. »
o « Il tag 'Pressure' ha un'impostazione che il driver NI-DAQmx non può usare. Aprirlo e correggere il campo che il pannello del tag segnala. »

La riga in sola lettura **Indirizzo di origine (bus)** mostra ciò che il driver riceve: il canale
come lo chiama NI-DAQmx e ogni impostazione della misura, ad esempio
`cDAQ1Mod1/ai0?measurement=voltageInput&terminal=diff&min=0&max=10`,
`cDAQ1Mod2/ai0?measurement=thermocouple&type=K&cjc=builtIn&min=0&max=400`,
`Dev1/port0/line3?measurement=digitalOutput` o
`cDAQ1/_ctr0?measurement=edgeCount&edge=rising&direction=up&initial=0&input=%2FcDAQ1Mod3%2FPFI0`.

## Lettura {#reading}

Il driver crea i task NI-DAQmx di un dispositivo quando la stazione vi si connette, e li tiene finché
non si disconnette. Ciò che fa una lettura, e ciò che NI-DAQmx risponde, decidono ciò che il tag
mostra (vedi [La catena di conversione](connector-value-pipeline)):

| Tag | Come vengono letti |
| --- | --- |
| Ingressi analogici (tensione, corrente, termocoppia) | Tutti gli ingressi analogici di un dispositivo condividono un task, che ogni lettura avvia, da cui prende un campione per canale e che poi ferma. Un dispositivo ha un motore di temporizzazione analogico, e un telaio cDAQ tre per tutti i suoi moduli, quindi un task tenuto avviato impedirebbe a un altro modulo di leggere. Una lettura che trova il motore occupato da un altro task (NI MAX, LabVIEW) chiede di nuovo due volte, a 25 ms di distanza. Un campione serve tutti i tag analogici del dispositivo per metà del più breve intervallo di interrogazione tra loro, quindi un modulo per termocoppie lento converte una volta per passata. |
| Un canale che NI-DAQmx rifiuta | Ogni canale analogico viene prima provato da solo: un canale che NI-DAQmx rifiuta (un campo che il modulo non ha, una termocoppia su un canale che non ne legge) fa fallire il proprio tag, non tutti i tag analogici del dispositivo. |
| Linee digitali, l'uscita in tensione, contatori | Un task per tag, avviato quando il dispositivo si connette. Un contatore conta da quel momento, e riparte dal suo conteggio iniziale quando il dispositivo si riconnette. |

| NI-DAQmx risponde | Che cosa fa la lettura |
| --- | --- |
| Un valore, o un avviso | Il valore, nell'unità della misura, prima che le fasi del tag stesso lo convertano. |
| Il dispositivo rimosso, irraggiungibile o reimpostato | Una connessione persa: il dispositivo si riconnette e i suoi task vengono creati di nuovo. |
| Nessuna risposta entro 10 secondi | Silenzio: il dispositivo si riconnette, e la politica del tag per [un dispositivo che non ha risposto](connector-value-pipeline#the-device-did-not-answer) decide che cosa mostra. |
| Qualsiasi altro errore | La lettura non riuscita di quel tag, con il testo di NI-DAQmx stesso e il suo codice; il dispositivo continua a leggere gli altri tag. |

La scalatura è la catena del tag stesso: il driver consegna volt, milliampere o gradi, e le fasi
Scalatura e Taratura li trasformano nel valore ingegneristico (da 0-10 V a 0-16 bar). Nessuna scala
personalizzata di NI MAX viene creata né letta.

## Scrittura {#writing}

Una **Linea di uscita digitale** e un'**Uscita in tensione** si scrivono; ogni altra misura è in sola
lettura. Una scrittura passa per lo stesso imbuto di quella di ogni altro driver: la casella di
scrittura prende il valore ingegneristico, e le fasi di conversione vengono invertite prima che il
valore grezzo venga inviato (vedi [Connector](connector)).

| Misura | Che cosa fa una scrittura |
| --- | --- |
| **Linea di uscita digitale** | Porta la linea alta per vero e bassa per falso. Il tag rilegge lo stato che la linea mantiene, salvo che sia di Sola scrittura. |
| **Uscita in tensione** | Porta l'uscita alla tensione scritta. Un valore fuori dal campo del tag viene rifiutato prima che qualcosa raggiunga il dispositivo. NI-DAQmx non rilegge un'uscita analogica, quindi il tag è di Sola scrittura e non mostra un valore proprio. |

Un valore che NI-DAQmx rifiuta torna come « Scrittura rifiutata dall'apparecchiatura: `<motivo>`. »,
con il numero di errore di NI-DAQmx come motivo (`NI-DAQmx -200561`), che si legge allo stesso modo in
ogni lingua, mentre le parole di NI-DAQmx stesso vanno nel diario tecnico; nessuna risposta entro 10 secondi dice « Scrittura non confermata: l'apparecchiatura non ha risposto in tempo. »
Una scrittura aspetta la lettura in corso sullo stesso dispositivo.

## Rilevamento {#discovery}

**Rileva**, sulla barra del driver, chiede a NI-DAQmx ogni dispositivo che NI MAX conosce, compresi
quelli simulati, e all'hardware non viene inviato nulla. Non prende alcun indirizzo. Mentre gira, la
riga di avanzamento nomina il dispositivo che sta leggendo: « Lettura di cDAQ1Mod1 da NI-DAQmx… ».
Senza NI-DAQmx non elenca nulla e dice « NI-DAQmx non è installato su questo computer, quindi non si può elencare alcun dispositivo. L'avviso nel pannello di questo driver indica il download e i passaggi di installazione. »

Ogni dispositivo è un candidato nominato con il suo nome e il suo prodotto (`cDAQ1Mod1 (NI 9205)`),
con i suoi canali come tag candidati, ciascuno con i valori predefiniti della sua misura:

| Canali | Offerti come |
| --- | --- |
| Ingressi analogici | **Termocoppia** su un modulo per termocoppie, un dispositivo che legge solo millivolt e dice di leggere una termocoppia (un NI 9211): tipo K, **Sensore integrato** e da 0 a 100 °C. Altrimenti **Ingresso in tensione** dove il canale legge una tensione, da -10 a 10 V o sul campo proprio del dispositivo dove questo è più stretto, e **Ingresso in corrente** o **Termocoppia** dove NI-DAQmx dice che il canale non legge tensione. Un modulo universale, che legge una tensione reale oltre a una termocoppia, offre ingressi in tensione: scegliere la misura sul tag una volta aggiunto. |
| Linee digitali | **Linea di ingresso digitale**, o **Linea di uscita digitale** dove la linea si limita a pilotare. |
| Uscite analogiche | **Uscita in tensione**, di Sola scrittura. |
| Contatori | **Conteggio dei fronti**. NI-DAQmx non elenca i contatori di un telaio cDAQ, quindi il telaio arriva senza tag: aggiungere a mano un tag su `_ctr0`, con il **Terminale di ingresso** dove arrivano gli impulsi, perché un contatore del telaio non ne ha uno proprio. |

Un candidato il cui nome è già letto da un dispositivo del driver viene marcato come già configurato
e offre Apri invece di Aggiungi. Il resto del comportamento della scansione è in
[Rilevamento](connector-discovery).

Un dispositivo che c'è già rilegge i suoi canali dalla sua stessa pagina: **Rileva tag**, nell'intestazione della sua scheda **Tag**, chiede a NI-DAQmx solo quel dispositivo e offre solo i canali per cui non ha ancora un tag, con i valori predefiniti della loro misura (vedere [Rilevare i tag di un dispositivo](connector-discovery#discovering-a-devices-tags)).

## Esempio: un telaio cDAQ {#example-a-cdaq-chassis}

Un telaio cDAQ-9178, che NI MAX chiama `cDAQ1`, porta un modulo in tensione NI 9205 nello slot 1, con
un trasmettitore di pressione 0-10 V cablato in differenziale sul suo primo canale, e un modulo per
termocoppie NI 9211 nello slot 2, con una termocoppia di tipo K in un forno. Leggerli entrambi:

1. Sulla pagina del driver, **Aggiungi dispositivo**; chiamarlo `Module voltages` e scrivere
   `cDAQ1Mod1` in **Nome del dispositivo**. Una volta connesso, **Prodotto** dice NI 9205.
2. **Aggiungi tag**; chiamarlo `Pressure`, **Canale fisico** `ai0`, tenere **Ingresso in tensione**,
   impostare il campo su 0 e 10 e la **Configurazione dei terminali** su **Differenziale**. Sulla
   scheda Conversione, attivare la fase Scalatura con un fattore di 1,6 e dare al tag l'unità bar:
   0-10 V si legge 0-16 bar.
3. Di nuovo **Aggiungi dispositivo**; chiamarlo `Oven thermocouples`, **Nome del dispositivo**
   `cDAQ1Mod2`.
4. **Aggiungi tag** `Zone1`, **Canale fisico** `ai0`, **Misura** **Termocoppia**, tenere **Tipo K** e
   **Sensore integrato**, e impostare il campo su 0 e 400.
5. Per contare impulsi sul telaio, un dispositivo il cui **Nome del dispositivo** è `cDAQ1` porta i
   contatori: un tag su `_ctr0` è un **Conteggio dei fronti**, con il **Terminale di ingresso** dove
   arrivano gli impulsi, ad esempio `/cDAQ1Mod3/PFI0`.

L'indirizzo di bus del tag `Pressure` dice
`cDAQ1Mod1/ai0?measurement=voltageInput&terminal=diff&min=0&max=10`. Un agente fa lo stesso con gli
strumenti; la termocoppia nomina la sua misura, perché `ai0` da solo si legge come un ingresso in
tensione:

```
device_upsert name="Module voltages" driver="NiDaqmx" daqmxDevice="cDAQ1Mod1"
tag_upsert device="Module voltages" name="Pressure" address="ai0" daqmxMinimum=0 daqmxMaximum=10 daqmxTerminal="Differential"
device_upsert name="Oven thermocouples" driver="NiDaqmx" daqmxDevice="cDAQ1Mod2"
tag_upsert device="Oven thermocouples" name="Zone1" address="ai0" daqmxMeasurement="Thermocouple" daqmxThermocouple="K" daqmxMaximum=400
device_upsert name="Chassis counters" driver="NiDaqmx" daqmxDevice="cDAQ1"
tag_upsert device="Chassis counters" name="Pulses" address="_ctr0" daqmxCounterTerminal="/cDAQ1Mod3/PFI0"
```

## Strumenti dell'agente {#agent-tools}

`driver_capabilities` descrive questo driver sotto `niDaqmx`: il nome del dispositivo e,
per ogni misura, un canale di esempio, l'unità, i suoi campi, i tipi di dato e gli accessi che
consente, con gli elenchi di scelta di ogni campo, come si comportano letture e scritture e che cosa
offre il rilevamento. `device_upsert driver=NiDaqmx` accetta `daqmxDevice`, il nome che NI MAX dà al
dispositivo (`''` lo cancella, e il dispositivo ne aspetta uno). `tag_upsert` accetta il canale come
`address` e i campi della sua misura: `daqmxMeasurement` (`VoltageInput`, `CurrentInput`,
`Thermocouple`, `DigitalInput`, `DigitalOutput`, `VoltageOutput` o `EdgeCount`; se omesso, il canale
porta la sua), `daqmxMinimum` e `daqmxMaximum`, `daqmxTerminal` (`Default`, `Differential`,
`ReferencedSingleEnded`, `NonReferencedSingleEnded` o `PseudoDifferential`), `daqmxShunt`
(`Default`, `Internal` o `External`) e `daqmxShuntOhms`, `daqmxThermocouple` (`J`, `K`, `N`, `R`,
`S`, `T`, `B` o `E`), `daqmxCjcSource` (`BuiltIn` o `ConstantValue`) e `daqmxCjcTemperature`,
`daqmxEdge` (`Rising` o `Falling`), `daqmxCountDirection` (`Up` o `Down`), `daqmxInitialCount` e
`daqmxCounterTerminal`. Un campo che la misura non legge viene rifiutato, quindi la chiamata nomina
solo ciò che si applica. Un dispositivo e un tag che gli strumenti restituiscono portano `niDaqmx`:
il nome del dispositivo, il suo prodotto una volta connesso e se NI-DAQmx è installato.
`device_discover driver=NiDaqmx` elenca ogni dispositivo che NI MAX conosce con i suoi canali come
tag candidati. Gli altri strumenti sono in [Strumenti dell'agente](agent-tools).

## Limiti da conoscere {#limits-worth-knowing}

- L'acquisizione continua non viene fatta. L'hardware può campionare con il proprio clock, migliaia
  di punti al secondo in un buffer; questo driver legge un campione per lettura, quindi serve i
  segnali lenti, e una forma d'onda o una vibrazione non viene letta.
- Il prodotto non include NI-DAQmx: senza di esso su questo computer i dispositivi restano offline,
  e la pagina del driver dice come installarlo ([NI-DAQmx su questo computer](#ni-daqmx-on-this-computer)). La stazione lo prende in carico senza riavvio.
- Il giunto freddo di una termocoppia viene dal sensore integrato del modulo o da una temperatura
  fissa; un giunto freddo letto da un altro canale non viene offerto.
- Un'uscita analogica non viene riletta: un tag di uscita in tensione è di Sola scrittura.
- Un task, un canale globale o una scala personalizzata salvati in NI MAX non vengono usati: ogni tag
  nomina un canale fisico, il driver costruisce i propri task, e la scalatura è la catena del tag.