Usar NI-DAQmx en entornos de programación basada en texto

Contenido

Descripción general

En general, la programación de adquisición de datos con DAQmx implica los siguientes pasos:

  • Crear una tarea y canales virtuales
  • Configurar los parámetros de temporización
  • Comenzar la tarea
  • Realizar una operación de lectura desde DAQ
  • Realizar una operación de escritura desde DAQ
  • Detener y borrar la tarea.

La adquisición de datos en un entorno de programación basado en texto es muy similar a la programación de LabVIEW NI-DAQmx, ya que las funciones de llamada son las mismas que los VIs de NI-DAQmx.

Crear una tarea y canales virtuales

Una canal virtual es una colección de configuraciones como un nombre, un canal físico, conexiones de terminales de entrada, tipo de medida o generación, y puede incluir información de escala.

Una tarea, un concepto importante para NI-DAQmx es una colección de uno o más canales virtuales con temporización, activación y otras propiedades. Conceptualmente, una tarea representa una medida o generación que usted desea realizar. Las tareas se pueden crear para operaciones de entrada y salida analógicas, entrada y salida digital y contador.

Para crear una tarea y un canal de entrada analógica en C, use las siguientes llamadas a funciones:

DAQmxCreateTask("", &taskHandle));

DAQmxCreateAIVoltageChan (taskHandle, "Dev1/ai0", "Voltage", DAQmx_Val_Cfg_Default, -10.0, 10.0, DAQmx_Val_Volts, NULL);

Para crear una tarea y un canal de entrada analógica en .NET, cree una instancia del objeto Tarea y cree un Canal como se muestra a continuación:

analogInTask = new Task();
AIChannel myChannel;
myChannel = analogInTask.AIChannels.CreateVoltageChannel(
    "dev1/ai0", //The physical name of the channel
    "myChannel", //The name to associate with this channel
    AITerminalConfiguration.Differential, //Differential wiring
    -10, //10v minimum
    10, //10v maximum
    AIVoltageUnits.Volts //Use volts

Configurar los parámetros de temporización

La mayoría de los dispositivos de adquisición de datos de NI utilizan un reloj de muestreo para controlar la velocidad a la que se adquieren y generan los muestreos. Este reloj de muestreo establece el intervalo de tiempo entre las muestras. Cada tic de este reloj inicia la adquisición o generación de una muestra por canal.

En el software, usted puede especificar el intervalo (la velocidad con la que el reloj adquiere o genera señales) especificando la frecuencia de muestreo. También puede limitar la razón de muestreo por el condicionamiento de la señal que usted aplique a las señales o al número de canales en su aplicación.

Para configurar los parámetros de temporización en C, llame a la función DAQmxCfgSamp como se muestra a continuación:

DAQmxCfgSampClkTiming(taskHandle, "", 10000.0, DAQmx_Val_Rising,

DAQmx_Val_FiniteSamps, 1000);

Para configurar los parámetros de temporización en .NET, use la propiedad Task.Timing  como se muestra a continuación:

analogInTask.Timing.ConfigureSampleClock(

"/Dev1/PFI0", // external clock source line or use "" for internal clock

10000, // expected rate of external clock or actual rate of internal clock

SampleClockActiveEdge.Rising, // acquire on rising or falling edge of ticks

SampleQuantityMode.ContinuousSamples, // continuous or finite samples

1000 // number of finite samples to acquire or used for buffer size if continuous

);

Cuando un dispositivo controlado por NI-DAQmx hace algo, realiza una acción. Dos acciones muy comunes son producir una muestra e iniciar una adquisición de forma de onda. Cada acción NI-DAQmx necesita un estímulo o causa. Cuando se produce el estímulo, se realiza la acción. Las causas de las acciones se llaman disparos. Los disparos se nombran después de las acciones que causan, como un disparo de inicio para iniciar una adquisición.

La función NI-DAQmx Trigger configura un disparo para realizar una especificación. Las acciones más usadas son un disparo de inicio y un disparo de referencia. Un disparo de inicio inicia una adquisición o generación. Un disparo de referencia establece la ubicación, en un juego de muestras adquiridas, dónde terminan los datos de pre-disparo y comienzan los datos de post-disparo. Estos dos disparos pueden ser configurados para ocurrir en un borde digital, un borde analógico o cuando una señal analógica entra o deja una ventana.

Para configurar un disparo de inicio en una señal digital ascendente que llega en la línea 0 PFI del dispositivo, utilice la función DAQmxCfgDigEdgeStartTrig en C:

DAQmxCfgDigEdgeStartTrig (taskHandle, "PFI0", DAQmx_Val_Rising);

Para configurar un disparo de inicio en .NET, use ConfigureDigitalEdgeTrigger en la colección Task.Triggers.StartTrigger como se muestra a continuación:

DigitalEdgeStartTriggerEdge triggerEdge = DigitalEdgeStartTriggerEdge.Rising;

analogInTask.Triggers.StartTrigger.ConfigureDigitalEdgeTrigger("PFI0, triggerEdge);

 

Comenzar la tarea

La función NI-DAQmx Start Task transforma explícitamente una tarea al estado de ejecución. En el estado de ejecución, la tarea realiza la adquisición o generación especificada. Una tarea será transformada implícitamente al estado de ejecución o iniciada automáticamente, si la función NI-DAQmx Start Task no es usada cuando la función NI-DAQmx Read se ejecuta. Esta transición implícita también ocurre si la función NI-DAQmx Start Task no es usada y la función NI-DAQmx Write se ejecuta con su entrada automática especificada como corresponde.

Para iniciar una tarea en C, use la función DAQmxStartTask :

DAQmxStartTask(taskHandle);

Para iniciar una tarea en .NET, use la función Task.Start:

analogInTask.start();

 

Operación de lectura o escritura

NI-DAQmx proporciona múltiples funciones para leer y escribir datos. En muchos casos, puede utilizar múltiples opciones. Las funciones de lectura y escritura tienen dos criterios principales de selección: formato de datos y organización de datos. El formato de datos especifica el tipo de datos que se devuelven. Las lecturas de contador, por ejemplo, pueden devolver enteros o formatos de punto flotante. La segunda categoría, organización de datos, se ocupa de la estructura en la que se devuelven los datos. Las lecturas analógicas, por ejemplo, tienen una variedad de arreglos y organizaciones escalares.

Dependiendo de la operación, los datos pueden ser adquiridos o generados. En el modo de adquisición, se requiere una operación de lectura para leer un número específico de muestras desde el búfer. En el modo de generación de datos, la muestra se ha escrito en el búfer de la tarjeta de adquisición de datos.

Para leer datos en C, use la llamada de función DAQmxReadAnalog:

DAQmxReadAnalogF64(taskHandle, 1000, 10.0, DAQmx_Val_GroupByChannel, data, 1000, &read, NULL)'

Para leer datos en .NET, cree un objeto ChannelReader, conéctelo a Task.Stream y luego llame a una función de lectura como se muestra a continuación:

//Create the reader and attach it to the stream
AnalogSingleChannelReader reader = new AnalogSingleChannelReader(analogInTask.Stream);
//Perform the read
double[] data = reader.ReadMultiSample(100);

Para obtener más información sobre la lectura y escritura de datos en .NET, consulte la sección "Lectura y Escritura con la Biblioteca NI-DAQmx .NET" de la Ayuda del NI-DAQmx .NET 2.0 Framework.

 

Detener y borrar la tarea

Después de completar una tarea, detenga la tarea y libere todos los recursos reservados. La función NI-DAQmx Clear Task borra la tarea especificada. Si la tarea se está ejecutando, primero la función detiene la tarea y después libera todos sus recursos. Una vez que la tarea ha sido borrada, no puede ser usada a menos que sea recreada. De esa manera, si una tarea será usada otra vez, la función NI-DAQmx Stop Task debe usarse para detener la tarea, pero no para borrarla.

Para detener y borrar una tarea en C use las siguientes funciones:

DAQmxStopTask(taskHandle);

DAQmxClearTask(taskHandle);

Para detener y borrar una tarea en .NET, use los métodos Task.Stop y Task.Dispose como se muestra a continuación:

analogInTask.Stop();

analogInTask.Dispose();

Interfaz de Programación de Aplicaciones (API) DAQmx

DAQmx viene con las API necesarias para la programación de adquisición de datos. La API de DAQmx es simplemente un conjunto de bibliotecas que contienen funciones para realizar todas las operaciones de adquisición de datos. Estas API incluyen soporte para LabWindows/CVI, C, C ++, Visual Basic 6.0, VB.NET y C #.

Las API de DAQmx se instalan junto con el controlador DAQmx y contienen los siguientes manuales de referencia:

  • Ayuda de NI-DAQmx Referencia C
  • Ayuda de Visual Basic 6.0 API NI-DAQmx C
  • Ayuda de NI-DAQmx .NET Framework 1.1 (Visual Studio 2003)
  • Ayuda de NI-DAQmx .NET Framework 2.0 (Visual Studio 2005)
  • Ayuda de NI-DAQmx .NET Framework 3.5 (Visual Studio 2008)
  • Ayuda de NI-DAQmx .NET Framework 4.0 (Visual Studio 2010)


Cada una de estas APIs contiene información detallada sobre cómo usar la biblioteca de funciones y clases para comunicarse y controlar un dispositivo de adquisición de datos (DAQ) de NI.

Programación de DAQmx en C

Este es un ejemplo de una operación de voltaje de entrada analógica para adquirir un número finito de muestras de voltaje desde un transductor usando una tarjeta de adquisición de datos de NI.

********************************************************************************

#include <stdio.h>
#include <NIDAQmx.h>
#define DAQmxErrChk(functionCall) if( DAQmxFailed(error=(functionCall)) ) goto Error; else

int main(void)
{
       int32       error=0;
       TaskHandle  taskHandle=0;
       int32       read;
       float64     data[1000];
       char        errBuff[2048]={'\0'};

// DAQmx analog voltage channel and timing parameters

DAQmxErrChk (DAQmxCreateTask("", &taskHandle));

DAQmxErrChk(DAQmxCreateAIVoltageChan(taskHandle, "Dev1/ai0", "", DAQmx_Val_Cfg_Default, -10.0, 10.0, DAQmx_Val_Volts, NULL));

DAQmxErrChk(DAQmxCfgSampClkTiming(taskHandle, "", 10000.0, DAQmx_Val_Rising, DAQmx_Val_FiniteSamps, 1000));

// DAQmx Start Code

DAQmxErrChk(DAQmxStartTask(taskHandle));

// DAQmx Read Code

DAQmxErrChk(DAQmxReadAnalogF64(taskHandle, 1000, 10.0, DAQmx_Val_GroupByChannel, data, 1000, &read, NULL));

// Stop and clear task

Error:
       if( DAQmxFailed(error) )
             DAQmxGetExtendedErrorInfo(errBuff,2048);
       if( taskHandle!=0 )  {
              DAQmxStopTask(taskHandle);
              DAQmxClearTask(taskHandle);
       }
       if( DAQmxFailed(error) )
              printf("DAQmx Error: %s\n",errBuff);
              return 0;
}

********************************************************************************

Nota: Es importante incluir el archivo header NIDAQmx.h en el programa main.c para tener acceso a la biblioteca DAQmx. 

En este código de ejemplo, esta función creó una tarea:

int32 DAQmxCreateTask (const char taskName[], TaskHandle *taskHandle);

Esto asignó un nombre a la tarea con una salida que hace referencia a la tarea creada. Esta función luego configuró un canal de voltaje virtual:

int32 DAQmxCreateAIVoltageChan (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], int32 terminalConfig, float64 minVal, float64 maxVal, int32 units, const char customScaleName[]);

Esta llamada de función especifica una referencia a la tarea creada, los nombres de los canales físicos, el nombre para asignar a los canales virtuales, la configuración de la terminal de entrada para el canal, el valor mínimo y máximo en la unidad que usted espera medir y el nombre de una escala personalizada para aplicar al canal.

Después de configurar los canales de voltaje virtuales, una función de ajuste del reloj de muestreo especificó la razón de muestreo, el modo de muestreo y la cantidad de muestras para leer:

int32 DAQmxCfgSampClkTiming (TaskHandle taskHandle, const char source[], float64 rate, int32 activeEdge, int32 sampleMode, uInt64 sampsPerChanToAcquire);

El modo de muestreo también se puede establecer en continuo usando la constante DAQmx_Val_ContSamps. Para comenzar a adquirir la muestra de voltaje, se debe llamar a la siguiente función con una referencia a la tarea configurada.

int32 DAQmxStartTask (TaskHandle taskHandle);

El DAQmxReadAnalogF64 lee múltiples muestras de punto flotante desde una tarea que contiene uno o más canales de entrada analógica como se muestra en la llamada de función.

int32 DAQmxReadAnalogF64 (TaskHandle taskHandle, int32 numSampsPerChan, float64 timeout, bool32 fillMode, float64 readArray[], uInt32 arraySizeInSamps, int32 *sampsPerChanRead, bool32 *reserved);

Aquí se leen 1000 muestras y se escriben en un arreglo del mismo tamaño que la cantidad de muestras adquiridas.

Finalmente, DAQmxStopTask y DAQmxClearTask, detienen la tarea y la devuelven al estado en que se encontraba antes de llamar a DAQmxStartTask y liberan los recursos reservados por la tarea. Usted no puede usar una tarea una vez que la borra sin volver a crearla o volver a cargarla.

Programación de DAQmx en .NET

Se puede escribir un pseudo-código similar para la misma operación utilizando la API para la biblioteca DAQmx de Microsoft .NET Framework para Visual Basic y C #. La API contiene clases, delegados y enumeraciones que proporcionan una interfaz .NET para NI-DAQmx. El código de ejemplo para una operación de lectura muy simple se muestra a continuación:

********************************************************************************

// Create a channel
   myTask.AIChannels.CreateVoltageChannel(physicalChannelComboBox.Text, "", (AITerminalConfiguration)(-1), rangeMinimum, rangeMaximum,    AIVoltageUnits.Volts);

// Configure timing specs
   myTask.Timing.ConfigureSampleClock("", sampleRate, SampleClockActiveEdge.Rising, SampleQuantityMode.FiniteSamples, samplesPerChannel);

// Verify the task
   myTask.Control(TaskAction.Verify);

// Prepare the table for data
   InitializeDataTable(myTask.AIChannels, ref dataTable);
   acquisitionDataGrid.DataSource = dataTable;

// Read the data
   reader = new AnalogMultiChannelReader(myTask.Stream);

// clear task
   myTask.Dispose();

********************************************************************************

Nota: La biblioteca de clase NationalInstruments.DAQmx debe incluirse para ejecutar con éxito el programa.

Código de Ejemplo

NI-DAQmx también viene con un conjunto de ejemplos para cada uno de los entornos de programación.  Puede encontrar ejemplos utilizando la API de C en una de las siguientes ubicaciones de directorio:
<Program Files>\National Instruments\NI-DAQ\Examples\DAQmx ANSI C
o
<Documents and Settings>\All Users\Documents\National Instruments\NI-DAQ\Examples\DAQmx ANSI C

Para la API de .NET, puede encontrar ejemplos en una de las siguientes ubicaciones de directorio:
C:\Program Files\National Instruments\MeasurementStudioVS2005\DotNET\Examples\DAQmx
o
<Documents and Settings>\All Users\Documents\National Instruments\NI-DAQ\Examples\DotNET2.0

Las carpetas llamadas VB contienen ejemplos de Visual Basic .NET, y las carpetas llamadas CS contienen ejemplos de C#.

Los ejemplos de Visual Basic 6.0 se pueden encontrar en una de las siguientes ubicaciones de directorio:
<Program Files>\National Instruments\NI-DAQ\Examples\Visual Basic 6.0
o
<Documents and Settings>\All Users\Documents\National Instruments\NI-DAQ\Examples\Visual Basic 6.0

Ayuda de NI-DAQmx y Documentación de API

Después de instalar el controlador NI-DAQmx y elegir el soporte para C y/o .NET, los accesos directos a la ayuda se ubicarán en el menú de inicio en Programs » National Instruments » NI-DAQ » Text-Based Code Support

La documentación adicional que cubre los conceptos de NI-DAQmx a profundidad se encuentra en la Ayuda NI-DAQmx ubicada en Programs » National Instruments » NI-DAQ