Digital I/O EA PLC module * USB module with 16*DI and 16*DO (digital inputs/outputs)

Description
This function opens a specific module.

Definition
ULONG DapiOpenModule(ULONG moduleID, ULONG nr);

Parameter
moduleID=Specifies the module to be opened (see delib.h)
nr=Specifies which module is to be opened.
nr=0 -> 1. Module
nr=1 -> 2. Module

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

Remark
The handle returned by this function is required 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(„Module could not be opened\n“);
return;
}

Description
This command closes an open module.

Definition
ULONG DapiCloseModule(ULONG handle);

Parameter
handle=This is the handle of an open module

Return value
None

Programming example

// Close module
DapiCloseModule(handle);

Description
This function returns the installed DELIB version.

Definition
ULONG DapiGetDELIBVersion(ULONG mode, ULONG par);

Parameter
mode=Mode with which the version is read out (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 version 1.32 installed
version = 132(hex)

Description
This function returns the hardware configuration (number of input and output channels) of the module.

Definition
ULONG DapiSpecialCommand(ULONG handle,
DAPI_SPECIAL_CMD_GET_MODULE_CONFIG, par, 0, 0);

Parameter
handle=This is the handle of an open module
Querying the number of digital input channels
par=DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_DI
Query number of digital input flip-flops
par=DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_DI_FF
Query number of digital input counters (16-bit counter)
par=DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_DI_COUNTER
Query number of digital input counters (48-bit counter)
par=DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_CNT48
Querying the number of digital output channels
par=DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_DO
Querying the number of digital pulse generator outputs
par=DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_PULSE_GEN
Querying the number of digital PWM outputs
par=DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_PWM_OUT
Querying the number of digital input/output channels
par=DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_DX
Querying the number of analog input channels
par=DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_AD
Querying the number of analog output channels
par=DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_DA
Query number of temperature channels
par=DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_TEMP
Query number of stepper channels
par=DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_STEPPER

Return value
Querying the number of digital input channels
return=number of digital input channels
Query number of digital input flip-flops
return=number of digital input flip-flops
Query number of digital input counters (16-bit counter)
return=number of digital input counters (16-bit counter)
Query number of digital input counters (48-bit counter)
return=number of digital input counters (48-bit counter)
Querying the number of digital output channels
return=number of digital output channels
Querying the number of digital pulse generator outputs
return=number of digital pulse generator outputs
Querying the number of digital PWM outputs
return=number of digital PWM outputs
Querying the number of digital input/output channels
return=number of digital input/output channels
Querying the number of analog input channels
return=number of analog input channels
Querying the number of analog output channels
return=number of analog output channels
Query number of temperature channels
return=number of temperature channels
Query number of stepper channels
return=number of stepper channels

Programming example

ret=DapiSpecialCommand(handle,
DAPI_SPECIAL_CMD_GET_MODULE_CONFIG,
DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_DI, 0, 0);
//Returns the number of digital input channels
ret=DapiSpecialCommand(handle,
DAPI_SPECIAL_CMD_GET_MODULE_CONFIG,
DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_DO, 0, 0);
//Returns the number of digital output channels
ret=DapiSpecialCommand(handle,
DAPI_SPECIAL_CMD_GET_MODULE_CONFIG,
DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_DX, 0, 0);
//Returns the number of digital input/output channels
ret=DapiSpecialCommand(handle,
DAPI_SPECIAL_CMD_GET_MODULE_CONFIG,
DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_AD, 0, 0);
//Returns the number of analog input channels
ret=DapiSpecialCommand(handle,
DAPI_SPECIAL_CMD_GET_MODULE_CONFIG,
DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_DA, 0, 0);
//Returns the number of analog output channels
ret=DapiSpecialCommand(handle,
DAPI_SPECIAL_CMD_GET_MODULE_CONFIG,
DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_STEPPER, 0, 0);
//Returns the number of stepper channels

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 defined. 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);

Parameter
moduleID = Specifies the module to be opened (see delib.h)
nr = Specifies which module (if several) is to be opened.
nr = 0 -> 1. Module
nr = 1 -> 2. 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

Remark
The handle returned by this function is required to identify the module for all other functions.
This command is supported by all modules with an 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);

Description
This function can be used to scan all modules connected to the USB bus.
The module ID and module no. of each module found are determined.

Definition
ULONG DapiScanAllModulesAvailable(uint nr)

Parameter
nr = 0: All modules connected to the USB bus are searched for
nr = i: Reading out the individual connected modules

Return value
Indicates the number of modules found.

Programming example

no_of_modules =
DT.Delib.DapiScanAllModulesAvailable(0);
for (i = 1; i <= no_of_modules; i++)
{
ret = DapiScanAllModulesAvailable(i);
moduleID = ret & 0x0000ffff;
moduleNr = (ret >> 16) & 0xff;
}

Description
This command executes a direct register write command to the module.

Definition
void DapiWriteByte(ULONG handle, ULONG adress, ULONG value);

Parameter
handle=This is the handle of an open module
adress=Address to be accessed
value=Specifies the data value that is written (8-bit)

Return value
None

Remark
This should only be used by experienced programmers. This allows direct access to all available registers.

Programming example

// Data is written to register 0x10
DapiWriteByte(handle, 0x10, 0xFF);

Description
This command executes a direct register write command to the module.

Definition
void DapiWriteWord(ULONG handle, ULONG adress, ULONG value);

Parameter
handle=This is the handle of an open module
adress=Address to be accessed
value=Specifies the data value that is written (16-bit)

Return value
None

Remark
This should only be used by experienced programmers. This allows direct access to all available registers.

Programming example

// Data is written to register 0x10
DapiWriteWord(handle, 0x10, 0xFFFF);

Description
This command executes a direct register write command to the module.

Definition
void DapiWriteLong(ULONG handle, ULONG adress, ULONG value);

Parameter
handle=This is the handle of an open module
adress=Address to be accessed
value=Specifies the data value that is written (32-bit)

Return value
None

Remark
This should only be used by experienced programmers. This allows direct access to all available registers.

Programming example

// Data is written to register 0x10
DapiWriteLong(handle, 0x10, 0xFFFFFFFF);

Description
This command executes a direct register write command to the module.

Definition
void DapiWriteLongLong(ULONG handle, ULONG adress, ULONGLONG value);

Parameter
handle=This is the handle of an open module
adress=Address to be accessed
value=Specifies the data value that is written (64-bit)

Return value
None

Remark
This should only be used by experienced programmers. This allows direct access to all available registers.

Programming example

// Data is written to register 0x10
DapiWriteLongLong(handle, 0x10, 0xFFFFFFFFFFFFFFFF);

Description
This command executes a direct register read command on the module.

Definition
ULONG DapiReadByte(ULONG handle, ULONG adress);

Parameter
handle=This is the handle of an open module
adress=Address to be accessed

Return value
Content of the register to be read (8-bit)

Remark
This should only be used by experienced programmers. This allows direct access to all available registers.

Programmierbeispiel

// Reads 8 bits from the address 0x0
ULONG data;
data = DapiReadByte(handle, 0x0);

Description
This command executes a direct register read command on the module.

Definition
ULONG DapiReadWord(ULONG handle, ULONG adress);

Parameter
handle=This is the handle of an open module
adress=Address to be accessed

Return value
Content of the register to be read (16-bit)

Remark
This should only be used by experienced programmers. This allows direct access to all available registers.

Programming example

// Reads 16 bits from the address 0x0
ULONG data;
data = DapiReadWord(handle, 0x0);

Description
This command executes a direct register read command on the module.

Definition
ULONG DapiReadLong(ULONG handle, ULONG adress);

Parameter
handle=This is the handle of an open module
adress=Address to be accessed

Return value
Content of the register to be read (32-bit)

Remark
This should only be used by experienced programmers. This allows direct access to all available registers.

Programming example

// Reads 32 bits from the address 0x0
ULONG data;
data = DapiReadLong(handle, 0x0);

Description
This command executes a direct register read command on the module.

Definition
ULONGLONG DapiReadLongLong(ULONG handle, ULONG address);

Parameter
handle=This is the handle of an open module
address=Address to be accessed

Return value
Content of the register to be read (64-bit)

Remark
This should only be used by experienced programmers. This allows direct access to all available registers.

Programming example

// Reads 64 bits from the address 0x0
ULONGLONG data;
data = DapiReadLongLong(handle, 0x0);

Description
This command reads a single digital input.

Definition
ULONG DapiDIGet1(ULONG handle, ULONG ch);

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

Return value
State 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

Programming example

// Read out 1 channel
unsigned long data;
data = DapiDIGet1(handle, 0);

Description
This command reads 8 digital inputs simultaneously.

Definition
ULONG DapiDIGet8(ULONG handle, ULONG ch);

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

Return value
State 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, ...)

Programming example

// Read out 8 channels
unsigned long data;
data = DapiDIGet8(handle, 0);

Description
This command reads 16 digital inputs simultaneously.

Definition
ULONG DapiDIGet16(ULONG handle, ULONG ch);

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

Return value
State 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, 16, 32, ...)

Programming example

// Read out 16 channels
unsigned long data;
data = DapiDIGet16(handle, 0);

Description
This command reads 32 digital inputs simultaneously.

Definition
ULONG DapiDIGet32(ULONG handle, ULONG ch);

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

Return value
State 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 (Eingang 1-31)
data = (unsigned long) DapiDIGet32(handle, 0);
// Chan Start = 0
printf("Input 0-31 : 0x%x\n", data);
printf("Press any key to continue\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("Press any key to continue\n");
getch();

Description
This command reads 64 digital inputs simultaneously.

Definition
ULONGLONG DapiDIGet64(ULONG handle, ULONG ch);

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

Return value
State 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)

Programming example

// Read out 64 channels
ULONGLONG data;
data = DapiDIGet64(handle, 0);

Description
This command reads the flip-flops of the inputs and resets them.

Definition
ULONG DapiDIGetFF32(ULONG handle, ULONG ch);

Parameter
handle=This is the handle of an open module
ch=Specifies the number of the input from which to read (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, ...)

Description
This command reads the input counter of a digital input.

Definition
ULONG DapiDIGetCounter(ULONG handle, ULONG ch, ULONG mode);

Parameter
handle=This is the handle of an open module.
ch=Specifies the number of the input from which to read.
mode=0 (normal counting function)
mode=DAPI_CNT_MODE_READ_WITH_RESET (read counter and reset counter directly)
mode=DAPI_CNT_MODE_READ_LATCHED (read out the stored counter reading)

Return value
Output of the counter value.

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

DAPI_SW_FEATURE_BIT_CFG_DI_CNT

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_COUNTER, 0, 0);
maxCh > ch

Programming example

value = DapiDIGetCounter(handle, 0 ,0); // Counter of DI Chan 0 is read
value = DapiDIGetCounter(handle, 1 ,0); // Counter of DI Chan 1 is read
value = DapiDIGetCounter(handle, 8 ,0); // Counter of DI Chan 8 is read
value = DapiDIGetCounter(handle, 0 ,DAPI_CNT_MODE_READ_WITH_RESET); // Counter of DI Chan 0 is read AND reset
value = DapiDIGetCounter(handle, 1, DAPI_CNT_MODE_READ_LATCHED); // Reading the stored meter reading from DI Chan 1

Description
This command saves the counter readings of all input counters simultaneously in a buffer (latch).
This allows all counter readings of the latch to be read out one after the other.
A special feature here is that it is possible to "freeze" the meter readings at the same time and the frozen readings (latch) can then be read out one after the other.

Definition
void DapiSpecialCommand(ULONG handle, DAPI_SPECIAL_CMD_COUNTER, DAPI_SPECIAL_COUNTER_LATCH_ALL, 0, 0);

Parameter
handle=This is the handle of an open module.
mode=DAPI_SPECIAL_CMD_COUNTER (It is a counter command)
mode=DAPI_SPECIAL_COUNTER_LATCH_ALL (Freezes all counter inputs and makes them available as a latch)

Remark
This command is only supported by our RO-O8-R8 time modules!

Programming example

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_COUNTER, DAPI_SPECIAL_COUNTER_LATCH_ALL, 0, 0);

Description
This command saves the counter readings of all input counters simultaneously in a buffer (latch). In addition, the counter readings of the input counters are subsequently reset.

Definition
void DapiSpecialCommand(ULONG handle, DAPI_SPECIAL_CMD_COUNTER, DAPI_SPECIAL_COUNTER_LATCH_ALL_WITH_RESET, 0, 0);

Parameter
handle=This is the handle of an open module.
mode=DAPI_SPECIAL_CMD_COUNTER (It is a counter command)
mode=DAPI_SPECIAL_COUNTER_LATCH_ALL_WITH_RESET (Freezes all counter inputs and makes them available as a latch and resets the counter of the input channels)

Remark
This command is only supported by our RO-O8-R8 time modules!

Programming example

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_COUNTER, DAPI_SPECIAL_COUNTER_LATCH_ALL_WITH_RESET, 0, 0);

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);

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

Remark
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

Description
This command returns the previously defined 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);

Parameter
handle=This is the handle of an open module

Return value
Time [ms]

Remark
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 scanning the digital input channels.

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

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

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

Remark
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

Description
This command returns the previously defined 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);

Parameter
handle=This is the handle of an open module

Return value
Time [ms]

Remark
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.

Description
This command sets a single output.

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

Parameter
handle=This is the handle of an open module
ch=Indicates the number of the output to be set (0 .. )
data=Indicates 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

Programming example

// Output 8 is set to 1
DapiDOSet1(handle, 7, 1);

Description
This command sets 8 digital outputs simultaneously.

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

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

Return value
None

Programming example

// Outputs 9-12 are set to 0
// Outputs 13-16 are set to 1
DapiDOSet8(handle, 8, 0xf0);

Description
This command sets 16 digital outputs simultaneously.

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

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

Return value
None

Programming example

// Outputs 1-8 are set to 0
// Outputs 9-16 are set to 1
DapiDOSet16(handle, 0, 0xff00);

Description
This command sets 32 digital outputs simultaneously.

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

Parameter
handle=This is the handle of an open module
ch=Specifies the number of the output from which to write (0, 32, 64, ..)
data=Indicates 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("Schreibe auf Ausgänge Daten=0x%x\n", data);
printf("Taste für weiter\n");
getch();
// ----------------------------------------------------
// Write a value to the outputs
data = 0x80000000; // Ausgang 32 wird auf 1 gesetzt
DapiDOSet32(handle, 0, data); // Chan Start = 0
printf("Schreibe auf Ausgänge Daten=0x%x\n", data);
printf("Taste für weiter\n");
getch();
// ----------------------------------------------------
// Write a value to the outputs
data = 0x80000000; // Ausgang 64 wird auf 1 gesetzt
DapiDOSet32(handle, 32, data); // Chan Start = 32
printf("Schreibe auf Ausgänge Daten=0x%x\n", data);
printf("Taste für weiter\n");
getch();

Description
This command sets 64 digital outputs simultaneously.

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

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

Return value
None

Programming example

// Outputs 1-32 are set to 0
// Outputs 33-64 are set to 1
DapiDOSet64(handle, 0, 0xffffffff00000000);

Description
This command reads back the 32 digital outputs.

Definition
ULONG DapiDOReadback32(ULONG handle, ULONG ch);

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

Return value
Status of 32 outputs.

Programming example

// Read back channel 1-32
unsigned long data;
data = DapiDOReadback32(handle, 0);

Description
This command reads back the 64 digital outputs.

Definition
ULONG DapiDOReadback64(ULONG handle, ULONG ch);

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

Return value
Status of 64 outputs.

Programming example

// Read back channel 1-64
unsigned long data;
data = DapiDOReadback64(handle, 0);

Description
This command can be used to switch outputs specifically to 1 without changing the states of the neighboring outputs.

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

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

Return value
None

Remark
Only the bits with a value of 1 in the data parameter are taken into account 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);

Description
This command can be used to switch outputs specifically to 0 without changing the states of the neighboring outputs.

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

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

Return value
None

Remark
Only the bits with a value of 1 in the data parameter are taken into account 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);

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

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

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

Return value
None

Remark
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

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 a so-called timeout event then occurs (pause between two accesses to the module is longer than the permitted timeout time), the following happens:
- All outputs are switched off.
- The timeout status changes to "2".
- The timeout LED goes on (for modules that have such a status)
Further access to the outputs is then still possible, but the timeout is no longer active. Only when it has been reactivated.

"auto reactivate" timeout
This is a timeout mode implemented since 2021, which automatically reactivates the timeout after the timeout event occurs.
Procedure for the timeout command:
The timeout is activated by command.
If a so-called timeout event then occurs (pause between two accesses to the module is greater than the permitted timeout time), the following happens:
- All outputs are switched off.
- The timeout status changes to "4".
- The timeout LED goes on (for modules that have such a status)
Further access to the outputs is 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, which prevents write access to the outputs after the timeout event occurs, thus ensuring that the software must first restore a "secure" state of the outputs, as the module's timeout mechanism has changed the outputs to predefined values.
Procedure for the timeout command:
The timeout is activated by command.
If a so-called timeout event then occurs (pause between two accesses to the module is longer than the permitted timeout time), the following happens:
- All outputs are switched off.
- The timeout status changes to "6".
- The timeout LED goes on (for modules that have such a status)
Further access to the outputs is NOT possible. The outputs can only be written to after the timeout has been reactivated or deactivated.

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

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)

Remark
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.7 sec.

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 access to the outputs is then still possible, but the timeout is no longer active.
Only when 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);
//The "normal" timeout is activated.

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 access to the outputs is 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.

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 a "secure" state of the outputs,
as the module's timeout mechanism 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 access to the outputs is NOT possible. Only after reactivating the
timeout or deactivating the timeout, the outputs can be written to.

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.

Description
This command deactivates 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);
//The timeout is deactivated.

Description
This command is used to read out 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 taken place)

Values for the "auto reactivate" timeout
Return = 3 ("auto reactivate" timeout is activated)
Return = 4 ("auto reactivate" timeout has occurred once or several times)

Values for the "secure" timeout
Return = 5 ("secure" timeout is activated)
Return = 6 (Timeout "secure" has taken place. Writing to the outputs is prevented in this status)

Programming example

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

Description
This command determines the outputs that are to be set 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_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 the event 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 event of a timeout.

Description
This command is used to read the transferred 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 that is transferred 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 transferred to the SET command is read out and displayed.

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 that 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 switched off in the event of a timeout.

Description
This command is used to read out the transferred 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 transferred 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 transferred to the CLR command is read out and displayed.

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

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.

Description
This function returns the last recorded error. If an error has occurred, it must be cleared with DapiClearLastError(), otherwise every call to DapiGetLastError() will return the "old" error.
If several modules are to be used, the use of DapiGetLastErrorByHandle() is recommended.

Definition
ULONG DapiGetLastError(void);

Parameter
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;
}

Description
This function returns the last error recorded for a specific module using the handle. If an error has occurred, it must be cleared with DapiClearLastErrorByHandle(), otherwise every call to DapiGetLastErrorByHandle() will return the "old" error.

Definition
ULONG DapiGetLastErrorByHandle(ULONG handle);

Parameter
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;
}

Description
This function reads out the text of the last recorded error. If an error has occurred, it must be cleared with DapiClearLastError(), otherwise every call to DapiGetLastErrorText() will return the "old" error.

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

Parameter
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;
}

Description
This function deletes the last error that was recorded with DapiGetLastError().

Definition
void DapiClearLastError(void);

Parameter
None

Return value
None

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;
}

Description
This function deletes the last error of a specific module (handle) that was registered with DapiGetLastErrorByHandle().

Definition
void DapiClearLastErrorByHandle(ULONG handle);

Parameter
handle=This is the handle of an open module.

Return value
None

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;
}

Description
This command checks the connection to an open module.

Definition
ULONG DapiPing(ULONG handle, ULONG value);

Parameter
handle=This is the handle of an open module
value=Transferred test value, in the value range of 0-255 (8-bit), to the module

Return value
The test value transferred with "value" must be returned here