USB digital I/O TTL module with 32/64 TTL-I/O

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 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 command sets the direction of 8 consecutive TTL inputs/outputs (1-bit wise).

Definition
void DapiSpecialCommand(ULONG handle, DAPI_SPECIAL_CMD_SET_DIR_DX_1, ULONG ch, ULONG dir, 0);

Parameter
handle = This is the handle of an open module
ch = Must always be 0!
dir = Indicates the direction for 8 channels (1=output / 0=input) / bit 0 stands for channel 0, bit 1 for channel 1 ...

Return value
None

Remark
Not compatible with USB-TTL-32/64.
Use the DAPI_SPECIAL_CMD_SET_DIR_DX_8 command for these modules.

Programming example

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SET_DIR_DX_1, 0, 0x01 , 0);
// Set Dir of TTL-I/O CH0 to output, others to input
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SET_DIR_DX_1, 0, 0x02 , 0);
// Set Dir of TTL-I/O CH1 to output, others to input
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SET_DIR_DX_1, 0, 0x04 , 0);
// Set Dir of TTL-I/O CH2 to output, others to input
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SET_DIR_DX_1, 0, 0x08 , 0);
// Set Dir of TTL-I/O CH3 to output, others to input
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SET_DIR_DX_1, 0, 0x10 , 0);
// Set Dir of TTL-I/O CH4 to output, others to input
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SET_DIR_DX_1, 0, 0x20 , 0);
// Set Dir of TTL-I/O CH5 to output, others to input
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SET_DIR_DX_1, 0, 0x40 , 0);
// Set Dir of TTL-I/O CH6 to output, others to input
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SET_DIR_DX_1, 0, 0x80 , 0);
// Set Dir of TTL-I/O CH7 to output, others to input
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SET_DIR_DX_1, 0, 0x0f , 0);
// Set Dir of TTL-I/O CH0-3 to output, others to input
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SET_DIR_DX_1, 0, 0xff , 0);
// Set Dir of TTL-I/O CH0-7 to output, others to input

Description
This command sets the direction of up to 64 consecutive TTL inputs/outputs (8-bit wise).
1-bit represents 8 TTL inputs/outputs.

Definition
void DapiSpecialCommand(ULONG handle, DAPI_SPECIAL_CMD_SET_DIR_DX_8, ULONG ch, ULONG dir, 0);

Parameter
handle = This is the handle of an open module
ch = Must always be 0!
dir = (8-bit) specifies the direction for up to 64 consecutive TTL inputs/outputs. (1=output / 0=input)

Return value
None

Remark
Only compatible with USB-TTL-32/64.
For other TTL products, use the DAPI_SPECIAL_CMD_SET_DIR_DX_1 command.

Programming example

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SET_DIR_DX_8, 0, 0x1 , 0);
// Set Dir of TTL-I/O CH0-7 to output, others to input
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SET_DIR_DX_8, 0, 0x3 , 0);
// Set Dir of TTL-I/O CH0-15 to output, others to input
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SET_DIR_DX_8, 0, 0xc , 0);
// Set Dir of TTL-I/O CH16-31 to output, others to input
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SET_DIR_DX_8, 0, 0x33 , 0);
// Set Dir of TTL-I/O CH0-15 and CH32-47 to output, others to input
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SET_DIR_DX_8, 0, 0xff , 0);
// Set Dir of TTL-I/O CH0-63 to output, others to input

Description
This command reads the direction of up to 64 consecutive TTL inputs/outputs (8-bit wise).
1-bit represents 8 TTL inputs/outputs.

Definition
ULONG DapiSpecialCommand(ULONG handle, DAPI_SPECIAL_CMD_GET_DIR_DX_8, ULONG ch, ULONG dir, 0);

Parameter
handle = This is the handle of an open module
ch = Must always be 0!
dir = Must always be 0!

Return value
Direction status of 64 channels.

Bit 0: Direction of TTL 0-7 / 1=output, 0=input
Bit 1: Direction of TTL 8-15 / 1=output, 0=input
Bit 2: Direction of TTL 16-23 / 1=output, 0=input
Bit 3: Direction of TTL 24-31 / 1=output, 0=input
Bit 4: Direction of TTL 32-39 / 1=output, 0=input
Bit 5: Direction of TTL 40-47 / 1=output, 0=input
Bit 6: Direction of TTL 48-55 / 1=output, 0=input
Bit 7: Direction of TTL 56-63 / 1=output, 0=input

Remark
Only compatible with USB-TTL-32/64.

Programming example

ULONG ret = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_GET_DIR_DX_8, 0, 0, 0);
// Reads the direction of 64 channels

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