DapiOpenModule

Description

This function opens a specific module

Definition

ULONG DapiOpenModule(ULONG moduleID, ULONG nr);

Parameters

moduleID=Specifies the module to be opened (see delib.h)
nr=Specifies which one (in case of several modules) should be opened.
nr=0 -> 1st module
nr=1 -> 2nd module

Return-Value

handle=Corresponding handle for the module
handle=0 -> module was not found

Comment

The handle returned by this function is needed to identify the module for all other functions.

Programming example

// Open USB module
handle = DapiOpenModule(RO_USB1, 0);
printf(“handle = %x\n”, handle);
if (handle==0)
{
// USB module was not found
printf(“Modul konnte nicht geöffnet werden\n”);
return;
}

DapiCloseModule

Description

This command closes an open module.

Definition

ULONG DapiCloseModule(ULONG handle);

Parameters

handle=This is the handle of an open module

Return-Value

None

Programming example

// Close module
DapiCloseModule(handle);

DapiGetLastError

Description

This function returns the last detected error. If an error occurred, it must be cleared with DapiClearLastError(), otherwise any call to DapiGetLastError() will return the “old” error.
If more than one module should be used, it is recommended to use DapiGetLastLastErrorByHandle().

Definition

ULONG DapiGetLastError(void);

Parameters

None

Return-Value

Error Code
0=no error. (see delib_error_codes.h)

Programming example

BOOL IsError()
{
unsigned char msg[500];
unsigned long error_code = DapiGetLastError();

if (error_code != DAPI_ERR_NONE)
{
DapiGetLastErrorText((unsigned char*) msg, sizeof(msg));
printf(“Error Code = 0x%x * Message = %s\n”, error_code, msg);

DapiClearLastError();

return TRUE;
}

return FALSE;
}

DapiGetLastErrorByHandle

Description

This function returns the last detected error of a specific module (handle). If an error occurred, it must be cleared with DapiClearLastErrorByHandle(), otherwise any call to DapiGetLastErrorByHandle() will return the “old” error.

Definition

ULONG DapiGetLastErrorByHandle(ULONG handle);

Parameters

handle=This is the handle of an open module

Return-Value

Error Code
0=no error. (see delib_error_codes.h)

Programming example

BOOL IsError(ULONG handle)
{
unsigned long error_code = DapiGetLastErrorByHandle(handle);

if (error_code != DAPI_ERR_NONE)
{
printf(“Error detected on handle 0x%x – Error Code = 0x%x\n”, handle, error_code);

DapiClearLastErrorByHandle(handle);

return TRUE;
}

return FALSE;
}

DapiGetLastErrorText

Description

This function reads the text of the last detected error. If an error occurred, it must be cleared with DapiClearLastError(), otherwise any call to DapiGetLastErrorText() will return the “old” error.

Definition

ULONG DapiGetLastErrorText(unsigned char * msg, unsigned long msg_length);

Parameters

msg = Buffer for the text to be received
msg_length = Length of the text buffer

Programming example

BOOL IsError()
{
unsigned char msg[500];
unsigned long error_code = DapiGetLastError();

if (error_code != DAPI_ERR_NONE)
{
DapiGetLastErrorText((unsigned char*) msg, sizeof(msg));
printf(“Error Code = 0x%x * Message = %s\n”, error_code, msg);

DapiClearLastError();

return TRUE;
}

return FALSE;
}

DapiClearLastError

Description

This function deletes the last error registered with DapiGetLastError().

Definition

void DapiGetLastError(void);

Parameters

None

Return value

None

Example program

BOOL IsError()
{
unsigned char msg[500];
unsigned long error_code = DapiGetLastError();

if (error_code != DAPI_ERR_NONE)
{
DapiGetLastErrorText((unsigned char*) msg, sizeof(msg));
printf(“Error Code = 0x%x * Message = %s\n”, error_code, msg);

DapiClearLastError();

return TRUE;
}

return FALSE;
}

DapiClearLastErrorByHandle

Description

This function deletes the last error of a particular module (handle), which was registered with DapiGetLastErrorByHandle().

Definition

void DapiClearLastErrorByHandle(ULONG handle);

Parameters

handle=This is the handle of an opened module.

Return value

None

Example program

BOOL IsError(ULONG handle)
{
unsigned long error_code = DapiGetLastErrorByHandle(handle);

if (error_code != DAPI_ERR_NONE)
{
printf(“Error detected on handle 0x%x – Error Code = 0x%x\n”, handle, error_code);

DapiClearLastErrorByHandle(handle);

return TRUE;
}

return FALSE;
}

DapiGetDELIBVersion

Description

This function returns the installed DELIB version.

Definition

ULONG DapiGetDELIBVersion(ULONG mode, ULONG par);

Parameters

mode=Mode with which the version is read (must always be 0).
par=This parameter is not defined (must always be 0).

Return-Value

version=Version number of the installed DELIB version [hex]

Programming example

version = DapiGetDELIBVersion(0, 0);
//With installed version 1.32 version = 132(hex)

DapiOpenModuleEx

Description

This function specifically opens a module with an Ethernet interface. The parameters IP address, port number and the duration of the timeout can be determined.
The module is opened independently of the settings made in the DELIB Configuration Utility.

Definition

ULONG DapiOpenModuleEx(ULONG moduleID, ULONG nr, unsigned char* exbuffer, 0);

Parameters

moduleID = Specifies the module to be opened (see delib.h)
nr = Specifies which one (in case of several modules) is to be opened
nr = 0 -> 1st module
nr = 1 -> 2nd module
exbuffer = buffer for IP address, port number and duration of the timeout

Return-Value

handle = Corresponding handle for the module
handle = 0 -> module was not found

Comment

The handle returned by this function is required to identify the module for all other functions.
This command is supported by all modules with Ethernet interface.

Programming example

// Open ETH-Module with parameter

DAPI_OPENMODULEEX_STRUCT open_buffer;

strcpy((char*) open_buffer.address, “192.168.1.10”);
open_buffer.portno = 0;
open_buffer.timeout = 5000;

handle = DapiOpenModuleEx(RO_ETH, 0, (unsigned char*) &open_buffer, 0);
printf(“Module handle = %x\n”, handle);

DapiDIGet1

Description

This command reads a single digital input.

Definition

ULONG DapiDIGet1(ULONG handle, ULONG ch);

Parameters

handle=This is the handle of an open module
ch= Specifies the number of the input to be read (0, 1, 2, 3, .. )

Return-Value

Status of the input (0/1)

Requirements

The following SW feature bits must be supported by the module:

DAPI_SW_FEATURE_BIT_CFG_DI

The following conditions for the transfer parameters must be met:

maxCh = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_GET_MODULE_CONFIG, DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_DI, 0, 0)
maxCh > ch

DapiDIGet8

Description

This command reads 8 digital inputs simultaneously.

Definition

ULONG DapiDIGet8(ULONG handle, ULONG ch);

Parameters

handle=This is the handle of an open module
ch= Specifies the number of the input from which the read is to start (0, 8, 16, 24, .. )

Return-Value

Status of the read inputs

Requirements

The following SW feature bits must be supported by the module:

DAPI_SW_FEATURE_BIT_CFG_DI

The following conditions for the transfer parameters must be met:

maxCh = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_GET_MODULE_CONFIG, DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_DI, 0, 0)
maxCh > ch ch must be 0, 8, 16, …

DapiDIGet16

Description

This command reads 16 digital inputs simultaneously.

Definition

ULONG DapiDIGet16(ULONG handle, ULONG ch);

Parameters

handle=This is the handle of an open module
ch= Specifies the number of the input from which the read is to start (0, 16, 32, …)

Return-Value

Zustand der gelesen Eingänge

Requirements

The following SW feature bits must be supported by the module:

DAPI_SW_FEATURE_BIT_CFG_DI

The following conditions for the transfer parameters must be met:

maxCh = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_GET_MODULE_CONFIG, DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_DI, 0, 0)
maxCh > ch ch must be 0, 16, 32, …

DapiDIGet32

Description

This command reads 32 digital inputs simultaneously.

Definition

ULONG DapiDIGet32(ULONG handle, ULONG ch);

Parameters

handle=This is the handle of an open module
ch= Specifies the number of the input from which the read is to start (0, 32, 64, ..)

Return-Value

Status of the read inputs

Requirements

The following SW feature bits must be supported by the module:

DAPI_SW_FEATURE_BIT_CFG_DI

The following conditions for the transfer parameters must be met:

maxCh = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_GET_MODULE_CONFIG, DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_DI, 0, 0)
maxCh > ch ch must be 0, 32, 64, …

Programming example

unsigned long data;
// —————————————————-
// Read a value from the inputs (input 1-31)
data = (unsigned long) DapiDIGet32(handle, 0);
// Chan start = 0
printf(“Input 0-31 : 0x%x\n”, data);
printf(“key for further\n”);
getch();
// —————————————————-
// Read a value from the inputs (input 32-64)
data = (unsigned long) DapiDIGet32(handle, 32);
// Chan Start = 32
printf(“Input 32-64 : 0x%x\n”, data);
printf(“key for further\n”);
getch();

DapiDIGet64

Description

This command reads 64 digital inputs simultaneously.

Definition

ULONGLONG DapiDIGet64(ULONG handle, ULONG ch);

Parameters

handle=This is the handle of an open module
ch= Specifies the number of the input from which the read is to start (0, 64, ..)

Return-Value

Status of the read inputs

Requirements

The following SW feature bits must be supported by the module:

DAPI_SW_FEATURE_BIT_CFG_DI

The following conditions for the transfer parameters must be met:

maxCh = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_GET_MODULE_CONFIG, DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_DI, 0, 0)
maxCh > ch ch must be 0 or 64

DapiDIGetFF32

Description

This command reads the flip-flops of the inputs and resets them.
(input state change)

Definition

ULONG DapiDIGetFF32(ULONG handle, ULONG ch);

Parameters

handle=This is the handle of an open module
ch= Specifies the number of the input from which the read is to start (0, 32, 64, ..)

Return-Value

Status of 32 input status changes

Requirements

The following SW feature bits must be supported by the module:

DAPI_SW_FEATURE_BIT_CFG_DI_FF

The following conditions for the transfer parameters must be met:

maxCh = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_GET_MODULE_CONFIG, DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_DI_FF, 0, 0)
maxCh > ch ch must be 0, 32, 64, …

DapiDOSet1

Description

This command sets a single output.

Definition

void DapiDOSet1(ULONG handle, ULONG ch, ULONG data);

Parameters

handle=This is the handle of an open module
ch= Specifies the number of the output to be set (0 .. )
data= Specifies the data value to be written (0 / 1)

Return-Value

None

Requirements

The following SW feature bits must be supported by the module:

DAPI_SW_FEATURE_BIT_CFG_DO

The following conditions for the transfer parameters must be met:

maxCh = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_GET_MODULE_CONFIG, DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_DO, 0, 0)
maxCh > ch

DapiDOSet8

Description

This command sets 8 digital outputs simultaneously.

Definition

void DapiDOSet8(ULONG handle, ULONG ch, ULONG data);

Parameters

handle=This is the handle of an open module
ch= Specifies the number of the output from which writing is to start (0, 8, 16, 24, 32, ..)
data=Specifies the data values to be written

Return-Value

None

DapiDOSet16

Description

This command sets 16 digital outputs simultaneously.

Definition

void DapiDOSet16(ULONG handle, ULONG ch, ULONG data);

Parameters

handle=This is the handle of an open module
ch= Specifies the number of the output from which writing is to start (0, 16, 32, ..)
data=Specifies the data values to be written

Return-Value

None

DapiDOSet32

Description

This command sets 32 digital outputs simultaneously.

Definition

void DapiDOSet32(ULONG handle, ULONG ch, ULONG data);

Parameters

handle=This is the handle of an open module
ch= Specifies the number of the output from which writing is to start (0, 32, 64, ..)
data=Specifies the data values to be written

Return-Value

None

Programming example

// Write a value to the outputs
data = 0x0000ff00; // outputs 9-16 are set to 1
DapiDOSet32(handle, 0, data); // Chan Start = 0
printf(“Write to outputs data=0x%x\n”, data);
printf(“key for further\n”);
getch();
// —————————————————-
// Write a value to the outputs
data = 0x80000000; // Output 32 is set to 1
DapiDOSet32(handle, 0, data); // Chan Start = 0
printf(“Write to outputs data=0x%x\n”, data);
printf(“key for further\n”);
getch();
// —————————————————-
// Write a value to the outputs
data = 0x80000000; // Output 64 is set to 1
DapiDOSet32(handle, 32, data); // Chan Start = 32
printf(“Write to outputs data=0x%x\n”, data);
printf(“key for further\n”);
getch();

DapiDOSet64

Description

This command sets 64 digital outputs simultaneously.

Definition

void DapiDOSet64(ULONG handle, ULONG ch, ULONGLONG data);

Parameters

handle=This is the handle of an open module
ch= Specifies the number of the output from which writing is to start (0, 64, ..)
data=Specifies the data values to be written

Return-Value

None

DapiDOClrBit32

Description

This command can be used to switch outputs selectively to 0 without changing the states of adjacent outputs.

Definition

void DapiDOClrBit32(uint handle, uint ch, uint data);

Parameters

handle = This is the handle of an open module
ch = Specifies the number of the output from which writing is to start
data = Specifies the data value to be written (up to 32 bits)

Return-Value

None

Comment

Only the bits with a value of 1 in the data parameter are considered by the command.

Programming example

data = 0x1; // Output 0 would be changed to 0. The states of outputs 1-31 won’t be changed
DapiDOSetBit32(handle, 0, data);

data = 0xf; // Outputs 0-3 would be changed to 0. The states of outputs 4-31 won’t be changed
DapiDOSetBit32(handle, 0, data);

data = 0xff; // Outputs 0-7 would be changed to 0. The states of outputs 8-31 won’t be changed
DapiDOSetBit32(handle, 0, data);

data = 0xff000000; // Outputs 23-31 would be changed to 0. The states of outputs 0-21 won’t be changed
DapiDOSetBit32(handle, 0, data);

DapiDOSet1_WithTimer

Description

This function sets a digital output (ch) to a value (data – 0 or 1) for a certain time in ms.

Definition

void DapiDOSet1_WithTimer(ULONG handle, ULONG ch, ULONG data, ULONG time_ms);

Parameters

handle=This is the handle of an open module
ch= Specifies the number of the output to be set (0 .. )
data= Specifies the data value to be written (0 / 1)
time_ms=Specifies the time in which the output is set [ms].

Return-Value

None

Comment

This command is supported by all output modules of the NET series as well as by our RO-O8-R8 module.
This command loses its validity if it is overwritten with other values.
If you want to deactivate the command, it must be overwritten with time_ms=0.

Programming example

DapiDOSet1_WithTimer(handle, 2, 1, 1000);
//Setting channel 2 for 1000msec to 1

DapiDOSetBit32

Description

This command can be used to switch outputs selectively to 1 without changing the states of adjacent outputs.

Definition

void DapiDOSetBit32(uint handle, uint ch, uint data);

Parameters

handle = This is the handle of an open module
ch = Specifies the number of the output from which writing is to start
data = Specifies the data value to be written (up to 32 bits)

Return-Value

None

Comment

Only the bits with a value of 1 in the data parameter are considered by the command.

Programming example

data = 0x1; // Output 0 would be changed to 1. The states of outputs 1-31 won’t be changed
DapiDOSetBit32(handle, 0, data);

data = 0xf; // Outputs 0-3 would be changed to 1. The states of outputs 4-31 won’t be changed
DapiDOSetBit32(handle, 0, data);

data = 0xff; // Outputs 0-7 would be changed to 1. The states of outputs 8-31 won’t be changed
DapiDOSetBit32(handle, 0, data);

data = 0xff000000; // Outputs 23-31 would be changed to 1. The states of outputs 0-21 won’t be changed
DapiDOSetBit32(handle, 0, data);

DapiDOReadback32

Description

This command reads back the 32 digital outputs.

Definition

ULONG DapiDOReadback32(ULONG handle, ULONG ch);

Parameters

handle=This is the handle of an open module
ch= Specifies the number of the output from which the read back is to be performed (0, 32, 64, ..)

Return-Value

Status of 32 outputs.

DapiDOReadback32

Description

This command reads back the 32 digital outputs.

Definition

ULONG DapiDOReadback32(ULONG handle, ULONG ch);

Parameters

handle=This is the handle of an open module
ch= Specifies the number of the output from which the read back is to be performed (0, 32, 64, ..)

Return-Value

Status of 32 outputs.

DapiSpecialCommand-DapiSpecialCMDTimeout

Description
This command is used to set the timeout protection function

There are three different timeout methods since 2021.

“normal” Timeout
This is the timeout that our modules have had since 2009.
Procedure for the timeout command:
The timeout is activated by command.
If then a so-called timeout event takes place (pause between two accesses to the module is greater than the allowed timeout time) the following happens:
– All outputs are switched off.
– The timeout status goes to “2”.
– The timeout LED turns on (for modules that have such a status).
Further accesses to the outputs are then still possible, but the timeout is no longer active. Not again until it has been reactivated.

“auto reactivate” Timeout
This is a timeout mode implemented since 2021 that automatically re-enables the timeout after the timeout event occurs.
Procedure for the timeout command:
The timeout is activated by command.
If then a so-called timeout event occurs (pause between two accesses to the module is greater than the allowed timeout time) the following happens:
– All outputs are switched off.
– The timeout status goes to “4”.
– The timeout LED turns on (for modules that have such a status).
Further accesses to the outputs are then still possible. AND the timeout is still active. If the timeout time is exceeded again, the outputs are switched off again.

“secure outputs” Timeout
This is a timeout mode implemented since 2021 that prevents write access to the outputs after the timeout event has occurred.This ensures that the software must first restore the outputs to a “safe” state because the module’s timeout mechanism has changed the outputs to predefined values.
Procedure for the timeout command:
The timeout is activated by command.
If then a so-called timeout event takes place(pause between two accesses to the module is greater than the allowed timeout time) the following happens:
– All outputs are switched off.
– The timeout status goes to “6”.
– The timeout LED turns on (for modules that have such a status).
Further access to the outputs is NOT possible. Only after reactivating the timeout or deactivating the timeout the outputs can be written.

Definition
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT, cmd, par1, par2);

Parameter
handle = This is the handle of an open module
cmd = Function to be executed
par1 = Value that is passed to the function
par2 = Value that is passed to the function

DapiSpecialCommand – DapiSpecialTimeoutSetValueSec

Description
This command is used to set the timeout time.

Definition
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT, cmd, par1, par2);

Parameter
cmd = DAPI_SPECIAL_TIMEOUT_SET_VALUE_SEC
par1 = seconds [s]
par2 = milliseconds [100ms] (value 6 = 600ms)

Comment

The permissible value range of the time specification is between 0.1 seconds and 6553 seconds

Programming example

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT,
DAPI_SPECIAL_TIMEOUT_SET_VALUE_SEC, 3, 7);
//The timeout time is set to 3,7sec.

DapiSpecialCommand – DapiSpecialTimeoutActivate

Description

This command activates the “normal” timeout.
After the timeout event,.
– ..all outputs are switched off
– ..the timeout status is set to “2
– ..the timeout LED is switched on (for modules that have such a status)
Further accesses to the outputs are then still possible, but the timeout is no longer active.
Not again until it has been reactivated.

Definition

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT, cmd, 0, 0);

Parameter
cmd = DAPI_SPECIAL_TIMEOUT_ACTIVATE

Programming example

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT,
DAPI_SPECIAL_TIMEOUT_ACTIVATE, 0, 0);
//Activates the “normal” timeout.

DapiSpecialCommand – DapiSpecialTimeoutActivateAutoReactivate

Description

This command activates the “auto reactivate” timeout.
In this mode, the timeout is automatically reactivated after the timeout event.
After the timeout event.
– ..all outputs are switched off
– ..the timeout status is set to “4
– ..the timeout LED is switched on (for modules that have such a status)
Further accesses to the outputs are then still possible AND the timeout is still active.
If the timeout time is exceeded again, the outputs are switched off again.

Definition

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT, cmd, 0, 0);

Parameter
cmd = DAPI_SPECIAL_TIMEOUT_ACTIVATE_AUTO_REACTIVATE

Programming example

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT,
DAPI_SPECIAL_TIMEOUT_ACTIVATE_AUTO_REACTIVATE, 0, 0);
//The “auto reactivate” timeout is activated.

DapiSpecialCommand – DapiSpecialTimeoutActivateSecureOutputs

Description

This command activates the “secure outputs” timeout.
In this mode, write access to the outputs is prevented after a timeout event.
This ensures that the software must first restore the outputs to a “secure” state,
because the timeout mechanism of the module has changed the outputs to predefined values.
After the timeout event.
– ..all outputs are switched off
– ..the timeout status is set to “6
– ..the timeout LED is switched on (for modules that have such a status)
Further accesses to the outputs are NOT possible. Only after reactivating the
timeout or deactivating the timeout the outputs can be written.

Definition

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT, cmd, 0, 0);

Parameter
cmd = DAPI_SPECIAL_TIMEOUT_ACTIVATE_SECURE_OUTPUTS

Programming example

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT,
DAPI_SPECIAL_TIMEOUT_ACTIVATE_SECURE_OUTPUTS, 0, 0);
//The “secure outputs” timeout is activated.

DapiSpecialCommand – DapiSpecialTimeoutDeactivate

Description

This command disables the timeout.

Definition

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT, cmd, 0, 0);

Parameter

cmd = DAPI_SPECIAL_TIMEOUT_DEACTIVATE

Programming example

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT,
DAPI_SPECIAL_TIMEOUT_DEACTIVATE, 0, 0);
//Deactivates the timeout

DapiSpecialCommand – DapiSpecialTimeoutGetStatus

Description

This command is used to read the timeout status.

Definition

ULONG DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT, DAPI_SPECIAL_TIMEOUT_GET_STATUS, 0, 0);

Parameter

cmd = DAPI_SPECIAL_TIMEOUT_GET_STATUS

Return-Value

Return = 0 (timeout is deactivated)

Values for the “normal” timeout
Return = 1 (Timeout “normal” is activated)
Return = 2 (Timeout “normal” has occurred)

Values for the “auto reactivate” timeout
Return = 3 (Timeout “auto reactivate” is activated)
Return = 4 (Timeout “auto reactivate” has occurred one or more times)

Values for the “secure” timeout
Return = 5 (Timeout “secure” is activated)
Return = 6 (Timout “secure” has taken place. In this status, writing to the outputs is prevented).

Programming example

unsigned long status = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT,
DAPI_SPECIAL_TIMEOUT_GET_STATUS, 0, 0);
printf(“Status = %ul\n”, status);
//Query timeout status with output

DapiSpecialCommand – DapiSpecialTimeoutDoValueMaskWRSet32

Description

This command determines the outputs to be set in case of a timeout.

Definition

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT, cmd, ch, par2);

Parameter

cmd = DAPI_SPECIAL_TIMEOUT_DO_VALUE_MASK_WR_SET32
ch = Specifies the number of the output from which to write (0, 32, 64, ..)
par2 = [32 Bit] Specifies the outputs which are to be activated in case of a timeout.

Programming example

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT,
DAPI_SPECIAL_TIMEOUT_DO_VALUE_MASK_WR_SET32, 0, 0xff);
//The first 8 relays are switched on in the timeout case.

DapiSpecialCommand – DapiSpecialTimeoutDoValueMaskRDSet32

Description

This command is used to read out the passed values

Definition

ULONG DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT, cmd, 0, 0);

Parameter

cmd = DAPI_SPECIAL_TIMEOUT_DO_VALUE_MASK_RD_SET32

Return-Value

[32 bit] Value passed to the SET command

Programming example

unsigned long value = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT,
DAPI_SPECIAL_TIMEOUT_DO_VALUE_MASK_RD_SET32, 0, 0);
printf(“%0x\n”, value);
//The value that was passed to the SET command is read out and displayed

DapiSpecialCommand – DapiSpecialTimeoutDoValueMaskWRClr32

Description

This command determines the outputs that are to be switched off in the event of a timeout.

Definition

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT, cmd, ch, par2);

Parameter

cmd = DAPI_SPECIAL_TIMEOUT_DO_VALUE_MASK_WR_CLR32
ch = Specifies the number of the output from which to write (0, 32, 64, ..)
par2 = [32 Bit] Specifies the outputs which are to be deactivated in the event of a timeout

Programming example

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT,
DAPI_SPECIAL_TIMEOUT_DO_VALUE_MASK_WR_CLR32, 0, 0xff);
//The first 8 relays are switechd off in the timeout case

DapiSpecialCommand – DapiSpecialTimeoutDoValueMaskRDClr32

Description

This command is used to read out the passed values.

Definition

LONG DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT, cmd, 0, 0);

Parameter

cmd = DAPI_SPECIAL_TIMEOUT_DO_VALUE_MASK_RD_CLR32

Return-Value

[32 Bit]Value that is passed to the CLR command

Programming example

unsigned long value = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT,
DAPI_SPECIAL_TIMEOUT_DO_VALUE_MASK_RD_CLR32, 0, 0);
printf(“%0x\n”, value);
//The value that was passed to the CLR command is read out and displayed

DapiSpecialCommand – DapiSpecialTimeoutDoValueLoadDefault

Description

Resets the SET and CLR values to the default value.
(SET value = 0, CLR value = FFFFFFFF)

Definition

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT, cmd, 0, 0);

Parameter

cmd = DAPI_SPECIAL_TIMEOUT_DO_VALUE_LOAD_DEFAULT

Programming example

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT,
DAPI_SPECIAL_TIMEOUT_DO_VALUE_LOAD_DEFAULT, 0, 0);
//SET and CRL values are set to the default value

DapiSpecialCommand-DapiSpecialCMDSWFifo

Description

This command is used to set the software FIFO.
DAPI_SPECIAL_CMD_SW_FIFO commands only work with the NET series.

Definition

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO, cmd, fifo_instance, par2);

Parameters

handle = This is the handle of an open module
cmd = function to be executed
fifo_instance = Specifies the instance of the software FIFO. So far there is only instance 0
par2 = value that is passed to the function

Remark

Always define the submodule first with the DapiSpecialSWFifoSetSubmodule command!

DapiSpecialCommand-DapiSpecialSWFifoSetSubmodule

Description

This command specifies to which submodule the data of the software FIFO are transferred.

Definition

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO, cmd, fifo_instance, par2);

Parameters

cmd = DAPI_SPECIAL_SW_FIFO_SET_SUBMODULE
fifo_instance = Specifies the instance of the software FIFO
par2 = indicates the number of the submodule (0, 1, 2, 3, …)

Programming example

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_SET_SUBMODULE, fifo_instance, 2);
//The software FIFO transfers the data to submodule 2.

DapiSpecialCommand – DapiSpecialSWFifoGetSubmodule

Description

This command returns the number of the submodule to which the data is transferred.

Definition

ULONG DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO, cmd, fifo_instance, 0);

Parameters

cmd = DAPI_SPECIAL_SW_FIFO_GET_SUBMODULE
fifo_instance = Specifies the instance of the software FIFO

Return value

Number of the submodule (0, 1, 2, 3, …)

Programming example

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_SET_SUBMODULE, fifo_instance, 2);
//The software FIFO transfers the data to submodule 2.

DapiSpecialCommand-DapiSpecialSWFifoActivate

Description

This command activates the Fifo data transfer within the NET modules.

Definition

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO, cmd, fifo_instance, 0);

Parameters

cmd = DAPI_SPECIAL_SW_FIFO_ACTIVATE
fifo_instance = Specifies the instance of the software FIFO

Programming example

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_ACTIVATE, fifo_instance, 0);
//The automatic output of the D/A converter is activated.

DapiSpecialCommand-DapiSpecialSWFifoDeactivate

Description

This command deactivates the Fifo data transfer within the NET modules.

Definition

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO, cmd, fifo_instance, 0);

Parameters

cmd = DAPI_SPECIAL_SW_FIFO_DEACTIVATE
fifo_instance = Specifies the instance of the software FIFO

Programming example

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_DEACTIVATE, fifo_instance, 0);
//The automatic output of the D/A converter is deactivated.

DapiSpecialCommand – DapiSpecialSWFifoGetActivity

Description

This command gets the status of the FIFO transmission to the D/A converter (whether active or inactive).

Definition

ULONG DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO, cmd, fifo_instance, 0);

Parameters

cmd = DAPI_SPECIAL_SW_FIFO_GET_ACTIVITY
fifo_instance = Specifies the instance of the software FIFO

Return value

Return = 0 (transmission is deactivated)
Return = 1 (transmission is activated)

Programming example

unsigned long ret = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_GET_ACTIVITY, fifo_instance, 0);
printf(“Status = %lu\n”, ret);
//transfer status is retrieved

DapiSpecialCommand – DapiSpecialSWFifoInitAndClear

Description

This command deletes existing data from the software FIFO memory and returns the FIFO mechanism to its original state.

Definition

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO, cmd, fifo_instance, 0);

Parameters

cmd = DAPI_SPECIAL_SW_FIFO_INIT_AND_CLEAR
fifo_instance = Specifies the instance of the software FIFO

Programming example

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_INIT_AND_CLEAR, fifo_instance, 0);
//existing data is deleted from the FIFO memory.

DapiSpecialCommand – DapiSpecialSWFifoIOActivate

Description

This command activates the FIFO I/O input/output.

Definition

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO, cmd, fifo_instance, 0);

Parameters

cmd = DAPI_SPECIAL_SW_FIFO_IO_ACTIVATE
fifo_instance = Gibt die Instanz des Software FIFO an

Programming example

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_IO_ACTIVATE, fifo_instance, 0);
//The automatic output of the FIFO to the module is activated.

DapiSpecialCommand – DapiSpecialSWFifoIODeactivate

Description

This command disables the FIFO I/O input/output.

Definition

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO, cmd, fifo_instance, 0);

Parameters

cmd = DAPI_SPECIAL_SW_FIFO_IO_DEACTIVATE
fifo_instance = Gibt die Instanz des Software FIFO an

Programming example

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_IO_DEACTIVATE, fifo_instance, 0);
//The automatic output of the FIFO to the module is deactivated.

DapiSpecialCommand – DapiSpecialSWFifoSetChannel

Description

This command specifies the A/D channels to which the FIFO data is to be transferred, specifying the start and end channels.

Definition

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO, cmd, fifo_instance, ch);

Parameters

cmd = DAPI_SPECIAL_SW_FIFO_SET_CHANNEL
fifo_instance = Specifies the instance of the software FIFO
ch = specification of the start and end channel

Programming example

unsigned long ch_start = 0; //Start with D/A Channel 0
unsigned long ch_end = 1; //End with D/A Channel 1

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_SET_Channel, fifo_instance,
((ch_end << 8) & 0xff00) | (ch_start & 0xff);
//The start and end channel is defined

DapiSpecialCommand-DapiSpecialSWFifoGetChannel

Description

This command shows the D/A channels to which the data is transferred.

Definition

ULONG DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO, cmd, fifo_instance, 0);

Parameters

cmd = DAPI_SPECIAL_SW_FIFO_GET_CHANNEL
fifo_instance = Specifies the instance of the software FIFO

Return value

Number of the A/D channels
Bit 0-7 Start channel
Bit 8-15 End channel

Programming example

unsigned long ret = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_GET_CHANNEL, fifo_instance, 0);
printf(“Channel = %lu\n”, ret);
//Shows on which A/D channels the data is transferred.

DapiSpecialCommand-DapiSpecialSWFifoSetFrequencyHz

Description

This command specifies the frequency interval (in Hertz) from the FIFO to the module.

Definition

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO, cmd, fifo_instance, par2);

Parameters

cmd = DAPI_SPECIAL_SW_FIFO_SET_FREQUENCY_HZ
fifo_instance = Specifies the instance of the software FIFO
par2 = frequency interval in Hertz (Hz)

Programming example

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_SET_FREQUENCY_HZ, fifo_instance, 10);
//Sets the frequency interval to 10Hz.

DapiSpecialCommand-DapiSpecialSWFifoGETFrequencyHz

Description

This command returns the previously set frequency interval in Hertz.

Definition

ULONG DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO, cmd, fifo_instance, 0);

Parameters

cmd = DAPI_SPECIAL_SW_FIFO_GET_FREQUENCY_HZ
fifo_instance = Specifies the instance of the software FIFO

Return value

Frequency interval in Hertz (Hz)

Programming example

unsigned long ret = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_GET_FREQUENCY_HZ, fifo_instance, 0);
printf(“Frequency = %lu (Hz)\n”, ret);
//Displays the previously set frequency interval.

DapiSpecialCommand-DapiSpecialSWFifoGetBytesFree

Description

This command is used to read the free bytes in the software FIFO buffer.

Definition

ULONG DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO, cmd, fifo_instance, 0);

Parameters

cmd = DAPI_SPECIAL_SW_FIFO_GET_BYTES_FREE
fifo_instance = Specifies the instance of the software FIFO

Return value

Free bytes of the software FIFO

Programming example

unsigned long ret = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_GET_BYTES_FREE, fifo_instance, 0);
printf(“Free memory = %lu\n”, ret);
//Output the remaining free bytes of the memory.

DapiSpecialCommand-DapiSpecialSWFifoGetBytesPerSample

Description

This command specifies how many bytes are required for writing to the D/A converter.
Example: If 3 D/A channels are written to a 16 bit (2 byte) D/A converter, 3×2 bytes are required per sample. So the value 6 will be returned.

Definition

ULONG DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO, cmd, fifo_instance, 0);

Parameters

cmd = DAPI_SPECIAL_SW_FIFO_GET_BYTES_PER_SAMPLE
fifo_instance = Specifies the instance of the software FIFO

Return value

Bytes required per sample

Programming example

unsigned long ret = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_GET_BYTES_PER_SAMPLE, fifo_instance, 0);
printf(“Required bytes = %lu\n”, ret);
//Output of the required bytes per sample.

DapiSpecialCommand-DapiSpecialSWFifoGetBytesPerSample

Description

This command specifies how many bytes are required for writing to the D/A converter.
Example: If 3 D/A channels are written to a 16 bit (2 byte) D/A converter, 3×2 bytes are required per sample. So the value 6 will be returned.

Definition

ULONG DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO, cmd, fifo_instance, 0);

Parameters

cmd = DAPI_SPECIAL_SW_FIFO_GET_BYTES_PER_SAMPLE
fifo_instance = Specifies the instance of the software FIFO

Return value

Bytes required per sample

Programming example

unsigned long ret = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_GET_BYTES_PER_SAMPLE, fifo_instance, 0);
printf(“Required bytes = %lu\n”, ret);
//Output of the required bytes per sample.

DapiSpecialCommand-DapiSpecialSWFifoSetMode

Description

This command sets the software FIFO mode. This command is not yet supported in the current firmware.

Definition

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO, cmd, fifo_instance, par2);

Parameters

cmd = DAPI_SPECIAL_SW_FIFO_SET_MODE
fifo_instance = Specifies the instance of the software FIFO
par2 = Software FIFO Mode

Programming example

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_SET_MODE, fifo_instance, 0);
//The software FIFO mode is set.

DapiSpecialCommand-DapiSpecialSWFifoGetMode

Description

This command returns the previously set FIFO mode. Currently this mode is not yet supported in the firmware.

Definition

ULONG DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO, cmd, fifo_instance, 0);

Parameters

cmd = DAPI_SPECIAL_SW_FIFO_GET_MODE
fifo_instance = Specifies the instance of the software FIFO

Return value

FIFO Software Mode

Programming example

unsigned long ret = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_GET_MODE, fifo_instance, 0);
printf(“Mode = %lu\n”, ret);
//Get the previously set FIFO mode.

DapiSpecialCommand-DapiSpecialSWFifoGetStatus

Beschreibung

This command can be used to retrieve status values.

Definition

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO, cmd, fifo_instance, 0);

Parameter

cmd = DAPI_SPECIAL_SW_FIFO_GET_STATUS
fifo_instance = Specifies the instance of the software FIFO

Return-Value

Programming example

unsigned long ret;

ret = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO,DAPI_SPECIAL_SW_FIFO_GET_STATUS, fifo_instance, 0);
if((ret & 0x01) != 0) {printf(“is_active”);}
if((ret & 0x02) != 0) {printf(“io_is_active”);}
if((ret & 0x04) != 0) {printf(“fifo_overflow”);}
if((ret & 0x08) != 0) {printf(“fifo_underrun”);}
if((ret & 0x10) != 0) {printf(“fifo_out_of_sync);}

DapiSpecialCommand-DapiSpecialCMDAD

Description

This command manages the control of the software FIFO of an A/D converter.

Definition

ULONG DapiSpecialCommand(ULONG handle, DAPI_SPECIAL_CMD_AD, ULONG cmd, ULONG ch_range, ULONG par0);

Parameters

handle = This is the handle of an open module
ch_range = Indicates the number of the A/D converter module (see example or file delib.h)

Initialize FIFO

cmd=DAPI_SPECIAL_RO_AD_FIFO_INIT
par0=not defined

Activate FIFO
cmd=DAPI_SPECIAL_RO_AD_FIFO_ACTIVATE
par0=not defined

Deactivate FIFO
cmd=DAPI_SPECIAL_RO_AD_FIFO_DEACTIVATE
par0=not defined

Set FIFO interval
cmd=DAPI_SPECIAL_RO_AD_FIFO_SET_INTERVAL_MS
par0=interval [msec]

Set FIFO for an A/D converter channel
cmd=DAPI_SPECIAL_RO_AD_FIFO_SET_CHANNEL
par0=16 bit value for A/D channels that are written to the FIFO. Each bit stands for one channel (Bit0 -> AD0, Bit1 -> AD1, … Bit15 -> AD15).
If the bit is set, the corresponding A/D channel is active.

Request FIFO status
cmd=DAPI_SPECIAL_RO_AD_FIFO_GET_STATUS
par0=not defined

Return-Value

cmd=DAPI_SPECIAL_RO_AD_FIFO_INIT
no return value

cmd=DAPI_SPECIAL_RO_AD_FIFO_ACTIVATE
no return value

cmd=DAPI_SPECIAL_RO_AD_FIFO_DEACTIVATE
no return value

cmd=DAPI_SPECIAL_RO_AD_FIFO_SET_INTERVAL_MS
no return value

cmd=DAPI_SPECIAL_RO_AD_FIFO_SET_CHANNEL
no return value

cmd=DAPI_SPECIAL_RO_AD_FIFO_GET_STATUS
return=current FIFO status

Value [hex] Meaning Explanation 0x80 RO_FIFO_STATUS_MASK_MEASURE_ENABLED FIFO is active 0x40 RO_FIFO_STATUS_MASK_TEST_DATA
0x20 RO_FIFO_STATUS_MASK_OVERFLOW FIFO Buffer is full 0x10 RO_FIFO_STATUS_MASK_UNDERRUN
0x08 RO_FIFO_STATUS_FULL_256_BYTE 256 Byte data available 0x04 RO_FIFO_STATUS_FULL_64_BYTE 64 Byte data available 0x02 RO_FIFO_STATUS_FULL_16_BYTE 16 Byte data available 0x01 RO_FIFO_STATUS_FULL_1_BYTE 1 Byte data available

Programming example

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_AD, DAPI_SPECIAL_RO_AD_FIFO_DEACTIVATE, DAPI_SPECIAL_AD_CH0_CH15, 0);
// deactivates the current AD-FIFO recording for AD module0 (channel 0 to 15)

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_AD, DAPI_SPECIAL_RO_AD_FIFO_INIT, DAPI_SPECIAL_AD_CH0_CH15, 0);
// initializing a new AD-FIFO recording for AD module 0 (channel 0 to 15)

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_AD, DAPI_SPECIAL_RO_AD_FIFO_SET_INTERVAL_MS, DAPI_SPECIAL_AD_CH0_CH15, 100);
// Set the AD-FIFO interval for recording to 100 ms for AD module 0 (channel 0 to 15).

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_AD, DAPI_SPECIAL_RO_AD_FIFO_SET_CHANNEL, DAPI_SPECIAL_AD_CH0_CH15, 0x1051);
// set the A/D channels to be recorded for AD module 0 (channel 0 to 15)
// 0x1051 [hex] = 0001 0000 0101 0001 0001 [bin]
// the following channels are recorded: AD0, AD4, AD6 and AD12

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_AD, DAPI_SPECIAL_RO_AD_FIFO_ACTIVATE, DAPI_SPECIAL_AD_CH0_CH15, 0);
// starts / activates the recording

status = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_AD, DAPI_SPECIAL_RO_AD_FIFO_GET_STATUS, DAPI_SPECIAL_AD_CH0_CH15, 0);
// get the current AD-FIFO status

DapiWriteFifo

Description

This command writes data records into the software FIFO.

Definition

DapiWriteFifo(ULONG handle, ULONG fifo_instance, ULONG type, UCHAR * buffer, ULONG buffer_length);

Parameters

handle=This is the handle of an open module
fifo_instance=Gives the instance of the software FIFO
type=Gives the FIFO type
buffer=Buffer for the record to be sent
buffer_length=Length of the buffer

Programming example

DapiWriteFifo(handle, fifo_instance, 0, buff, pos);
//Writes the data set to the software FIFO.

DapiReadFifo

Description

This command reads the software FIFO. The data sets read out are deleted from the module’s software FIFO after reading.

Definition

ULONG DapiReadFifo(ULONG handle, ULONG type, UCHAR * buffer, ULONG buffer_length);

Parameters

handle=This is the handle of an open module
fifo_instance=Gives the instance of the software FIFO
type=Gives the FIFO type
buffer=Buffer for the record to be received
buffer_length=Length of the buffer

Return-Value

Length of the read FIFO data records

Structure of a FIFO data record (example with 2 active AD channels, AD0 and AD4)

Byte || Meaning || Value [hex]

0 RO_FIFO_ID_START 0xf0

1 FIFO type
2 Time stamp (Bit0..Bit7)
3 Time stamp (Bit8..Bit15)
4 Active A/D channels (Bit0..Bit7) 0x11

5 Active A/D channels (Bit8..Bit15) 0x00

6 A/D value channel 0 (Bit0..Bit7)
7 A/D value channel 0 (Bit8..Bit15)
8 A/D value channel 4 (Bit0..Bit7)
9 A/D value channel 4 (Bit8..Bit15)
10 RO_FIFO_ID_END 0xf1

FIFO data set = 7 bytes ID + (2 x number of active A/D channels) bytes data

RO_FIFO_ID_START

Signals the beginning of a new FIFO data record. The RO_FIFO_ID_START always has the value 0xf0 [hex].

FIFO type

Specifies the FIFO type (e.g. RO_FIFO_ID_TYPE_AD16M0 for A/D-FIFO)

Time stamp

Specifies the 16 bit time stamp of the current record. The time reference here is the time of activation of the FIFO.
If the time stamp overflows, it is reset to 0.

Active A/D channels

Specifies a 16 bit value for the currently active A/D channels. Each bit represents one channel (Bit0 -> AD0, Bit1 -> AD1, … Bit15 -> AD15).
If the bit is set, the corresponding A/D channel is active

RO_FIFO_ID_END
Signals the end of a FIFO data record. The RO_FIFO_ID_END always has the value 0xf1 [hex].

Comment

This command is only supported by our RO-ETH series modules.
Please note that the software FIFO must be activated or initialized with the command “DapiSpecialCMDAD”.

Programming example

bytes_received = DapiReadFifo(handle, DAPI_FIFO_TYPE_READ_AD_FIFO, buffer, sizeof(buffer));
// Reads the Software FIFO

DapiCnt48ModeSet

Description

This command sets a counting mode (optionally also sub mode) and input filter for a specific input counter channel.

Definition

void DapiCnt48ModeSet(ULONG handle, ULONG ch, ULONG mode);

Parameters

handle=This is the handle of an open module
ch=number of the input counter channel whose mode is to be set (0, 1, 2, 3, .. )
mode= Specifies the mode

Possible values for mode

mode=DAPI_CNT48_MODE_COUNT_RISING_EDGE | DAPI_CNT48_SUBMODE_NO_RESET
In this mode, counting is performed on the rising edge.

mode=DAPI_CNT48_MODE_COUNT_RISING_EDGE | DAPI_CNT48_SUBMODE_RESET_WITH_READ
In this mode, counting is performed on the rising edge. In addition, the counter is reset with every read operation.

mode=DAPI_CNT48_MODE_COUNT_RISING_EDGE | DAPI_CNT48_SUBMODE_RESET_ON_CH_7
In this mode, counting is performed on the rising edge. In addition, the counter can be reset via an external signal (last channel of the module = 1).

mode=DAPI_CNT48_MODE_COUNT_RISING_EDGE | DAPI_CNT48_SUBMODE_LATCH_COMMON
With the command “DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_CNT48, DAPI_SPECIAL_CNT48_LATCH_GROUP8, 0, 0)” all 8 counter values of the input counters are written into a latch simultaneously. This mode can then be used to read the latched counter reading.

mode=DAPI_CNT48_MODE_T
This mode is used to measure the period T. A 100 MHz counter serves as a basis for this.

mode=DAPI_CNT48_MODE_FREQUENCY
In this mode the number of rising edges within one second (= frequency) can be measured.

mode=DAPI_CNT48_MODE_PWM
This mode is used to measure the “high” and “low” time of a signal. The ratio can then be determined (PWM).

Additionally, all input counters can be combined with an input filter (with an or combination). The following input filters are available for this:

DAPI_CNT48_FILTER_20ns
DAPI_CNT48_FILTER_100ns
DAPI_CNT48_FILTER_250ns
DAPI_CNT48_FILTER_500ns
DAPI_CNT48_FILTER_1us
DAPI_CNT48_FILTER_2_5us
DAPI_CNT48_FILTER_5us
DAPI_CNT48_FILTER_10us
DAPI_CNT48_FILTER_25us
DAPI_CNT48_FILTER_50us
DAPI_CNT48_FILTER_100us
DAPI_CNT48_FILTER_250us
DAPI_CNT48_FILTER_500us
DAPI_CNT48_FILTER_1ms
DAPI_CNT48_FILTER_2_5ms
DAPI_CNT48_FILTER_5ms

Comment

This command is only supported by our module RO-CNT8.

Programming example

DapiCnt48ModeSet(handle, 0, DAPI_CNT48_MODE_COUNT_RISING_EDGE | DAPI_CNT48_SUBMODE_RESET_WITH_READ | DAPI_CNT48_FILTER_20ns);
//input counter channel 0 counts all pulses <= 20ns on rising edge. In addition, the counter is reset after a query.
DapiCnt48ModeSet(handle, 1, DAPI_CNT48_MODE_COUNT_RISING_EDGE | DAPI_CNT48_SUBMODE_RESET_ON_CH_7 | DAPI_CNT48_FILTER_500us);
//input counter channel 1 counts all pulses <= 500us on rising edge. This counter can be reset with an external signal (ch7 = 1).
DapiCnt48ModeSet(handle, 2, DAPI_CNT48_MODE_PWM | DAPI_CNT48_FILTER_5ms);
//input counter channel 2 measures all low-/high times <= 5ms. The ratio is then determined (PWM).

DapiCnt48ModeGet

Description

This instruction reads back the count mode of a specific input counter channel.

Definition

ULONG DapiCnt48ModeGet(ULONG handle, ULONG ch);

Parameters

handle=This is the handle of an open module
ch=number of the input counter channel whose mode is to be output (0, 1, 2, 3, .. )

Return-Value

Counting mode of the input counter channel.
(More information / description of the bits -> see delib.h or manual “RO register assignment”)

Comment

This command is only supported by our module RO-CNT8.

Programming example

value = DapiCnt48ModeGet(handle, 0)
//G Returns the count mode of input counter channel 0
value = DapiCnt48ModeGet(handle, 3)
//G Returns the counting mode of input counter channel 3

DapiCnt48CounterGet32

Description

This command reads the first 32 bits of a 48-bit input counter.

Definition

ULONG DapiCnt48CounterGet32(ULONG handle, ULONG ch);

Parameters

handle=This is the handle of an open module
ch= Specifies the number of the input counter channel to be read (0, 1, 2, 3, .. )

Return-Value

Output of the counter value.

Comment

This command is only supported by our modules RO-CNT8 and RO-CNT/IGR.

Programming example

value = DapiCnt48CounterGet32(handle, 0);
//outputs the value of input counter channel 0
value = DapiCnt48CounterGet32(handle, 3);
//outputs the value of input counter channel 3

DapiCnt48CounterGet48

Description

Dieser Befehl liest einen 48 Bit Zähler eines Eingangszählerkanals.

Definition

ULONGLONG DapiCnt48CounterGet48(ULONG handle, ULONG ch);

Parameters

handle=This is the handle of an open module
ch= Specifies the number of the input counter channel to be read (0, 1, 2, 3, .. )

Return-Wert

Output of the counter value.

Comment

This command is only supported by our modules RO-CNT8 and RO-CNT/IGR.

Programming example

value = DapiCnt48CounterGet48(handle, 0);
//outputs the value of input counter channel 0
value = DapiCnt48CounterGet48(handle, 3);
//outputs the value of input counter channel 3

DapiSpecialCommand – Dapi_Special_DI_Filter_Value_Set

Description

This command sets a filter [ms], in which time interval digital input channels are sampled.

Definition

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_DI, DAPI_SPECIAL_DI_FILTER_VALUE_SET, ULONG time_ms, 0);

Parameters

handle=This is the handle of an opened module.
time_ms=Time interval [ms] by which digital input channels are sampled.

Remarks

This command only supports pulse times between 5ms and 255ms.
If no time is set, the default value is 100ms.

This command is not supported by our modules with Ethernet interface.

Programming example

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_DI, DAPI_SPECIAL_DI_FILTER_VALUE_SET, 5, 0);
// Sets the time interval to 5ms
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_DI, DAPI_SPECIAL_DI_FILTER_VALUE_SET, 150, 0);
// Sets the time interval to 150ms

DapiSpecialCommand – Dapi_Special_DI_Filter_Value_Get

Description

This command returns the previously set value of the time interval for sampling the digital input channels in [ms].

Definition

ULONG DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_DI, DAPI_SPECIAL_DI_FILTER_VALUE_GET, 0, 0);

Parameters

handle=This is the handle of an open module

Return-Value

Time [ms]

Remarks

This command is not supported by our modules with Ethernet interface.

Programming example

value = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_DI, DAPI_SPECIAL_DI_FILTER_VALUE_GET, 0, 0);
//Returns the time interval for sampling the digital input channels

DapiSpecialCommand – Dapi_Special_DI_FF_Filter_Value_Set

Description

This command sets a filter [ms], in which time interval the input flip-flops and the input counters are polled.

Definition

void DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_DI, DAPI_SPECIAL_DI_FF_FILTER_VALUE_SET, ULONG time_ms, 0);

Parameters

handle=This is the handle of an open module
time_ms=Time interval [ms] by scanning digital input channels.

Return-Value

None.

Comment

This command only supports pulse times between 5ms and 255ms.
If no time is set, the default value is 100ms.

This command is not supported by our modules with Ethernet interface.

Programming example

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_DI, DAPI_SPECIAL_DI_FF_FILTER_VALUE_SET, 5, 0);
// Sets the time interval to 5ms
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_DI,
DAPI_SPECIAL_DI_FF_FILTER_VALUE_SET, 150, 0);
// Sets the time interval to 150ms

DapiSpecialCommand – Dapi_Special_DI_FF_Filter_Value_Get

Description

This command returns the predefined value of the time interval for sampling the input flip-flops and the input counters in [ms].

Definition

ULONG DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_DI, DAPI_SPECIAL_DI_FF_FILTER_VALUE_GET, 0, 0);

Parameters

handle=This is the handle of an open module

Return-Value

Time [ms]

Comment

This command is not supported by our modules with Ethernet interface.

Programming example

value = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_DI, DAPI_SPECIAL_DI_FF_FILTER_VALUE_GET, 0, 0);
// Returns the time interval for scanning the digital input channels.

DapiSpecialCommand – DapiSpecialCNT48LatchGroup8

Description

This instruction stores the counter readings of 8 input counters simultaneously in a latch.
Thus, all counter readings of the latch can be read out one after the other.
A special feature is that a simultaneous “freezing” of the counter readings is possible and the frozen readings (latch) can then be read out (slowly) one after the other.

Definition

void DapiSpecialCommand(ULONG handle, DAPI_SPECIAL_CMD_CNT48, DAPI_SPECIAL_CNT48_LATCH_GROUP8, ULONG ch, 0)

Parameters

handle=This is the handle of an open module
ch=Specifies the number of the input counter from which the counter status of 8 input counters are latched (0, 8, 16, …)

Comment

This command is only supported by our module RO-CNT8.

Please regard that only the counter readings of the input counters are latched for which the mode

“DAPI_CNT48_SUBMODE_LATCH_COMMON” was set. (-> DapiCnt48ModeSet)

Programming example

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_CNT48, DAPI_SPECIAL_CNT48_LATCH_GROUP8, 0, 0)
// Counter values of the input counters 0-7 are latched
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_CNT48, DAPI_SPECIAL_CNT48_LATCH_GROUP8, 8, 0)
// Counter values of the input counters 8-15 are latched

DapiSpecialCommand – DapiSpecialCNT48ResetGroup8

Description

This command simultaneously resets the counts of 8 input counters.

Definition

void DapiSpecialCommand(ULONG handle, DAPI_SPECIAL_CMD_CNT48, DAPI_SPECIAL_CNT48_RESET_GROUP8, ULONG ch, 0)

Parameters

handle=This is the handle of an open module
ch=Specifies the number of the input counter from which the counter status of 8 input counters are reset (0, 8, 16, …)

Comment

This command is only supported by our module RO-CNT8.

Programming example

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_CNT48, DAPI_SPECIAL_CNT48_RESET_GROUP8, 0, 0)
// Counter values of the input counters 0-7 are reset
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_CNT48, DAPI_SPECIAL_CNT48_RESET_GROUP8, 8, 0)
// Counter values of the input counters 8-15 are reset

DapiSpecialCommand – DapiSpecialCNT48ResetSingle

Description

This command resets the count of a single input counter.

Definition

void DapiSpecialCommand(ULONG handle, DAPI_SPECIAL_CMD_CNT48, DAPI_SPECIAL_CNT48_RESET_SINGLE, ULONG ch, 0)

Parameters

handle=This is the handle of an open module
ch= Specifies the number of the input counter whose counter value is to be reset (0, 1, 2, ..)

Comment

This command is only supported by our module RO-CNT8.

Programming example

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_CNT48, DAPI_SPECIAL_CNT48_RESET_SINGLE, 0, 0)
// Counter reading of input counter 0 is reset
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_CNT48, DAPI_SPECIAL_CNT48_RESET_SINGLE, 1, 0)
// Counter reading of input counter 1 is reset

DapiSpecialCommand – DapiSpecialCNT48DIGet1

Description

This command reads the input state (0/1) of a digital input counter channel.

Definition

ULONG DapiSpecialCommand(ULONG handle, DAPI_SPECIAL_CMD_CNT48, DAPI_SPECIAL_CNT48_DI_GET1, ULONG ch, 0);

Parameters

handle=This is the handle of an open module
ch= Specifies the number of the input counter channel whose input state is to be read (0, 1, 2, 3, .. )

Return-Value

Status of the input counter (0/1)

Comment

This command is only supported by our module RO-CNT8.

Programming example

value = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_CNT48, DAPI_SPECIAL_CNT48_DI_GET1, 0, 0)
// Reads input status of input counter channel 1
value = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_CNT48, DAPI_SPECIAL_CNT48_DI_GET1, 1, 0)
// Reads input status of input counter channel 2