BS-ETH-USB module with 32/64 optocoupler inputs

0 customer reviews

ab  354,38

Availability: In Stock SKU: BS-ETH-O32/64,BS-USB-O32/64 Category:

Clear

This BS-ETH/BS-USB module is available in versions with 32 or 64 inputs. AC optocouplers are used for the digital inputs. The module housing consists of a stable aluminum profile with DIN rail mounting.

  • Ethernet interface 10/100 Mbit with electrical isolation
  • USB 2.0 interface up to 480 Mbit
  • 32/64 Digital inputs: 15V – 30V AC/DC (optional 5V – 15V)
  • 16 bit counter (up to 100Hz) / flipflop per channel
  • Robust aluminium housing (suitable for top hat rail mounting)

Digital inputs

With our optocoupler inputs, digital signal states can be recorded within a voltage range of 5V to 30V AC or DC. Input and output circuits are galvanically isolated from each other up to 2.5kV.

 

Counter

Each input has a 16 bit counter that can count up to 65535 pulses. If the maximum counter value is exceeded, the counting process starts again from zero. By means of a software command, the current status of all input counters can be written simultaneously into a separate memory area.

 

Recording of status changes

Status changes that occur between the readout cycles are reliably detected by internal flip-flops and can be read out separately by software. In addition, such an event is signalled by a status LED. Resetting is done automatically after the flip-flops have been read out.


LEDs

Each digital input and output has a separate LED that lights up when the signal state is active. Furthermore, the status of the operating voltage, the communication with the interface, error events or the occurrence of a timeout can be displayed.


Connectors

A screwless system from the manufacturer WAGO Kontakttechnik is used as the connector. The 1-wire female connectors are 100% protected against mismating and have an eject and locking mechanism. All conductor types up to 1.5mm² can be connected.


Software and control

Our DELIB driver library, which is included with the product, makes it easy to address the product via our API.

 

We offer support for the following programming languages:

  • C
  • C++
  • C#
  • VB
  • VBA
  • VB.Net
  • Java
  • Delphi
  • LabVIEW

We offer support for the following operating systems:

  • Windows 10 (32bit/64bit)
  • Windows 8/8.1 (32bit/64bit)
  • Windows 7 (32bit/64bit)
  • Windows Vista (32bit/64bit)
  • Windows XP (32bit/64bit)
  • Windows Server 2003 (32bit/64bit)
  • Windows 2000
  • Linux

Corresponding programming examples can be found in the “Software” section of the products or are included on the driver CD.


Additional information

Interfaces Variation

,

Number of digital inputs

,

General

Power supply via external power supply unit + 7V to +24V DC (via two-pin pluggable screw terminal)
Power supply via USB port*

+5V / 500mA (This mode cannot be used with all BS-USB module variants due to the higher current consumption!)

 

*Not possible with the BS-ETH variant

LEDs • Operating voltage
• Interface activity
• ERROR
• Input status change
• Timout shutdown
• I/O Access
• One LED per input channel
Connectors • Type: Wago Kontakttechnik 713-1108/037-000
• Pluggable 16 pin female connector with locking mechanism
• 100 % malfunction protected
• 1-wire connection for all types of conductors up to 1.5mm²
DIN rail mounting TS 35
Operating temperature +10°C .. +50°C
Dimensions with 32 inputs 105 mm x 135 mm x 74,5 mm (H x W x D)
Dimensions with 64 inputs 105 mm x 230 mm x 74,5 mm (H x W x D)

USB-Interface

Interface • USB 2.0 with up to 480 Mbit/s

Ethernet-Interface

Interface • 10/100 Mbit Ethernet (electrically isolated up to 1.5kV/AC 1 min)
• Configuration via the DELIB Configuration Utility (IP address, net mask …)
IP-Address • DHCP or static
API library • Easy to integrate C-library for access to the inputs and outputs
DIP switches • DHCP ON/OFF
• EEPROM write protection ON/OFF
• BOOT with EEPROM ON/OFF
• SERVICE Mode ON/OFF

Digital inputs

Optocoupler inputs • 15V to 30V DC/AC signal voltage (optional 5V – 15V DC/AC)
• Galvanic isolation between input and output circuit : up to 2.5kV AC for 1 minute
• Maximum input current: 14mA
Input counter • 16 bit counter per channel
• Maximum possible counting operations: 65535 / channel
• Reset to zero after memory overflow
• Internal counting logic up to 100Hz
• Programmable filter for input channels (flip-flop and counter):
• Minimum low or high pulse duration: 5ms…255ms
Input state flags (flip-flops) • Detects a change from low to high and high to low level
• Detects the input state change between two readout processes
• Input state flag is reset during readout

Configuration

Configuration of Ethernet modules

Modules with a 10/100 Mbit Ethernet interface can be connected directly to a PC or to a network LAN. The following two options are available for configuration:

 

1. Web interface

The Ethernet module has its own web server that can be used to change the following parameters:

 

  • IP address
  • Netmask
  • Std. Gateway
  • DNS Server

2. DELIB Configuration Utiliy

With the DELIB Configuration Utility the network can be automatically searched for DEDITEC products. All modules found can then be configured with a few clicks. The following parameters can be displayed and partly changed:

 

  • MAC address
  • DHCP or static IP
  • IP address
  • Module name
  • Product type
  • Netmask
  • Std.-Gateway
  • Port
  • Connection timeout
  • Encryption
  • Name assignment for I/Os

Advanced options

View advanced setting options for network settings, encryption and I/O naming.


Port and timeout

Additional options for the connection timeout and the port used can be specified.


Encryption options

If desired, a secure connection with user name and password can be established.


I/O Name Assignment

It is possible to name I/Os. This function facilitates the handling of the I/Os and is for convenience. This function is only available for products with Ethernet interface.

The DELIB Configuration Utility is installed with the DELIB 2.0 driver library and can be downloaded here

 

DELIB driver library

 


More details about the control and some programming examples can be found in the programming section.


Configuration of USB modules

Products with USB interface are automatically recognized by the DELIB driver library. A configuration is only necessary if several identical USB products are to be used on the same system.

 


Several identical USB modules on one system

Each of our USB products has the module number “0” in the delivery state. When using more than one USB module on a PC / system, a new module number must first be assigned to each additional module. This assignment is done with our DELIB configuration utility. Only in this way can a clear assignment be made by the software. The module number is stored permanently in the product. Up to 255 identical modules can be used on one system.


More details about the control and some programming examples can be found in the programming section.

Programming of modules via the DELIB driver library on Windows

The comprehensive yet very easy to use DELIB driver library is suitable for almost any programming language. An installation package with extensive examples can be found on our CD or in the download section.

Downloads

 

 

Control via the Windows driver library DELIB

The DELIB driver library enables a uniform response of all DEDITEC control engineering products. For this purpose, we provide programmers with appropriate functions for the respective product groups, which enable a uniform but also very simple addressing of the products.

 

Here you will find an overview of the DELIB and its programs:

DELIB + Tools

 

A list of all DELIB commands can be found here:

Overview DELIB API

 


The DELIB enables simple addressing of DEDITEC modules

 

The following example shows how simple means can be used to access the inputs of our modules within a very short time.

 

Open the module

handle = DapiOpenModule(RO_ETH,0); // Open Ethernet-Module

 

Read 16 digital inputs

data = DapiDIGet16(handle, 0); // Read the first 16 digital inputs

 

Close Module

DapiCloseModule(handle); // Close the module

 

The function “DapiOpenModule” is used to open a product. Which product is to be opened is determined by the two transferred parameters. The first parameter designates the “Module ID”. Due to the included “DELIB.H” the parameter can be simply specified with “RO_USB1”. This tells the driver library that a RO module with USB bus is to be addressed.

 

The second parameter determines the module number. If only one module is connected to the PC, a “0” is specified. If several modules are connected, the corresponding module number must be specified. The module number can be changed with the DELIB Configuration Utility.


 

Example of the addressing of a DEDITEC module

DEDITEC-Module Demo

The scope of delivery includes the DT module Demo. This program offers the possibility to address all inputs/outputs in a simple way and thus also to test them.

In this example a RO-ETH is connected. The connected RO-ETH has PT100 temperature sensors, relay outputs and stepper motor controls.

 


Control of Ethernet modules via TCP/IP using our open Ethernet protocol

If required, you can program your own control system yourself. The protocol that describes the communication via TCP/IP is disclosed. The control is register-based. For this purpose, a communication protocol has been created which is used to address the registers of the module and thus execute read or write commands. The manual “Protocols & Register Assignment” describes the send and receive frames to communicate with our Ethernet modules.

 

Ethernet Protocol Documentation


Programming of USB modules

Example for opening several modules on one PC:

 

Opening the module with the nr. “1”

handle1 = DapiOpenModule(RO_USB1,1); // Open USB-Modul with Nr=1

Opening the module with the nr. “4”

handle2 = DapiOpenModule(RO_USB1,4); // Open USB-Modul with Nr=4

General Handling

DapiOpenModule
This function opens a particular module.

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
This command closes an opened module.

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
This function returns the last registered error. If an error has occurred, it must be deleted with DapiClearLastError(), otherwise any call of DapiGetLastError() will return the "old" error. If multiple modules are used, the use of DapiGetLastErrorByHandle() is recommended.

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
This function returns the last registered error of a particular module (handle). If an error has occurred, it must be deleted with DapiClearLastErrorByHandle(), otherwise any call of DapiGetLastErrorByHandle() will return the "old" error.

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
This function reads the text of the last registered error. If an error has occurred, it must be cleared with DapiClearLastError(), otherwise every call of DapiGetLastErrorText() returns the "old" error. Definition

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
This function deletes the last error registered with DapiGetLastError().

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
This function deletes the last error of a particular module (handle), which was registered with DapiGetLastErrorByHandle().

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
This function returns the installed DELIB version.

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
This function opens a specific module with ethernet interface.The particularity of this command is,that parameters like IP-address, portnumber and the duration of the timeout can be specified. The opening of the module is independent of the DELIB Configuration Utility settings.

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

Digital input functions

DapiDIGet1
This command reads a single digital input.

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
This command reads 8 digital inputs simultaneously.

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
This command reads 16 digital inputs simultaneously.

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
This command reads 32 digital inputs simultaneously.

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
This command reads 64 digital inputs simultaneously.

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
This command reads the flip-flops from the inputs and resets them. (Input state change).

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, …

Software FIFO-functions

DapiSpecialCMDSoftwareFifo
This command controls the configuration of the Software-FIFO of the RO-ETH-Modules.

DapiSpecialCMDSoftwareFifo

 

Description

This command manages the control of the software FIFO for RO-ETH modules.

 

Definition

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

 

Parameters

handle=This is the handle of an open module

 

Activate software FIFO
cmd=DAPI_SPECIAL_SOFTWARE_FIFO_ACTIVATE

Deactivate software FIFO
cmd=DAPI_SPECIAL_SOFTWARE_FIFO_DEACTIVATE

Software FIFO status request
cmd=DAPI_SPECIAL_SOFTWARE_FIFO_GET_STATUS

 

Return-Value

cmd=DAPI_SPECIAL_SOFTWARE_FIFO_ACTIVATE
no return value

cmd=DAPI_SPECIAL_SOFTWARE_FIFO_DEACTIVATE
no return value

cmd=DAPI_SPECIAL_SOFTWARE_FIFO_GET_STATUS
return=0 (software FIFO deactivated)
return=1 (software FIFO activated)

 

Programming example

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SOFTWARE_FIFO, DAPI_SPECIAL_SOFTWARE_FIFO_ACTIVATE, 0, 0);
// Activates the software FIFO

status = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SOFTWARE_FIFO, DAPI_SPECIAL_SOFTWARE_FIFO_GET_STATUS, 0, 0);
// Reads the status of the software FIFO

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SOFTWARE_FIFO, DAPI_SPECIAL_SOFTWARE_FIFO_DEACTIVATE, 0, 0);
// Deactivates the software FIFO

DapiReadFifo
This command reads the Software-FIFO. The data sets will be deleted automatically from the Software-FIFO after reading.

DapiReadFifo

 

Description

This command reads the software FIFO. The data records 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
type = Returns the FIFO type to be read
buffer = buffer for the data records to be received
buffer_length = Length of the record 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 commands “DapiSpecialCMDSoftwareFifo” and “DapiSpecialCMDAD”.

 

Programming example

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

DapiSpecialCMDAD
This command controls the Software FIFO of a A/D converter.

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_AD_FIFO_INIT
par0=not defined

Activate FIFO
cmd=DAPI_SPECIAL_AD_FIFO_ACTIVATE
par0=not defined

Deactivate FIFO
cmd=DAPI_SPECIAL_AD_FIFO_DEACTIVATE
par0=not defined

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

Set FIFO for an A/D converter channel
cmd=DAPI_SPECIAL_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_AD_FIFO_GET_STATUS
par0=not defined

 

Return-Value

cmd=DAPI_SPECIAL_AD_FIFO_INIT
no return value

cmd=DAPI_SPECIAL_AD_FIFO_ACTIVATE
no return value

cmd=DAPI_SPECIAL_AD_FIFO_DEACTIVATE
no return value

cmd=DAPI_SPECIAL_AD_FIFO_SET_INTERVAL_MS
no return value

cmd=DAPI_SPECIAL_AD_FIFO_SET_CHANNEL
no return value

cmd=DAPI_SPECIAL_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_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_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_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_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_AD_FIFO_ACTIVATE, DAPI_SPECIAL_AD_CH0_CH15, 0);
// starts / activates the recording

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

CNT48 functions

DapiCnt48ModeSet
This command sets the count mode for a single input channel.

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
This command returns the count mode of a single input channel.

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
This command reads the first 32 bits of a 48 bit input counter.

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
This command reads a 48 bit counter of an input counter.

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_FF_Filter_Value_Set
This command sets a filter [ms], in which time interval the digital inputs are sampled.

DapiSpecialCommand – Dapi_Special_DI_FF_Filter_Value_Set

 

Description

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

 

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
This command returns the filter [ms], in which time interval the digital inputs are sampled.

DapiSpecialCommand – Dapi_Special_DI_FF_Filter_Value_Get

 

Description

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

 

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
This command saves the counter values of 8 inputcounters simultaneously into a temporary storage (latch). So, after that, the counter values of the latch can be read successively. Here, the speciality is, that it is possible to "freeze" the counter simultaneously and the frozen counter (latch) can be read one by one.

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
This command resets the counter values of 8 inputcounter simultaneously.

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
This commands resets the counter value of a single inputcounter.

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
This command reads the input state (0/1) of a single inputcounterchannel.

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

Web Interface – Interface

All DEDITEC Ethernet modules have a web interface that allows you to make settings conveniently via your web browser and also gives you direct access to the I/Os.

This allows you to access the product with a smartphone, tablet or even a PC via a browser.

The following I/O units are supported:

 

  • Digital inputs
  • Digital inputs (counter function)
  • Digital outputs
  • Analog inputs (voltage & current)
  • Analogue outputs (voltage & current)
  • PT100 temperature detection
  • Stepper motor control

You can protect the Ethernet module against unauthorized access with a user system and optional encryption system.

General

Start page of the web interface. The navigation on the left side gives you access to various setting options.

Network configuration

All network settings can be made directly via the web interface.

Usermanager

Here you can define the user name and password for access to the web interface. If the user is inactive, he/she is automatically logged out after the session time has expired.

Status / Reboot

Version of the installed firmware. Functions for restarting and resetting the settings.

Security

In addition to a user/password system for the web interface, we also offer you the option of encrypting the entire network communication. Access to the I/Os can also be blocked.

Supported I/Os

In the following we show you the supported I/Os that you can operate via the web interface.

Digital Inputs

The picture shows the overview of the digital inputs. You can switch between several inputs via the drop-down menu. The column ‘State’ shows whether a signal is present at the input.

Digital Inputs Counter

Our digital inputs have a counting function. The counter reading can be read and reset via the web interface.

Digital Outputs

The digital outputs can be switched via an on/off button. The current status of the outputs can be read back via the ‘Readback’ column.

Analogue Inputs

Current and voltage can also be read out via the web interface. The desired operating mode can be set via the A/D Mode drop-down menu.

Analogue Outputs

Analogue signals can also be output via the web interface. The desired D/A mode can be set via the drop-down menu, as with the analog inputs. The desired value can be written to the outputs using the ‘SET’ button. The column ‘Readback’ shows the current voltage/current output of the D/A converter.

Temperature measurement (PT100)

The temperature measurement is supported by our RO series.

 

PT100

The current temperature can be read. If no sensor is connected to the channel, this is signalled with ‘disconnected’.

Stepper-Motor Control

The position and speed of the stepper motor can be set via the control elements. The status window shows the current position, temperature and power supply.

I/O Control APP for Android™

 

Get it on Google Play

 

 

 

Control the digital and analog I/Os of our Ethernet modules from on the road. With the DEDITEC I/O control Android App, any network-compatible Android device can be remotely controlled for DEDITEC products with Ethernet interface

 

Features:

  • Separate storage of network settings for private and public networks
  • Better clarity through configurable I/O names
  • Configurable refresh of all I/Os

The following I/Os are supported:

  • up to 128 analog inputs (0..10V, 0..5V, +/- 10V and +/- 5V)
  • up to 64 analog outputs (0..10V, 0..5V, +/- 10V and +/- 5V)
  • up to 128 digital inputs and outputs

Network settings
A configuration for private (WLAN) or public (Internet) networks can be created and saved in the network settings.


Module configuration

At the module configuration you see the number of connected I/O modules.

You can also select here which I/Os are to be controlled.


Digital inputs
The digital inputs are scanned at an adjustable interval.


Digital outputs
In the area of the digital outputs the channels can be switched on or off individually.

It is also possible to switch all channels on or off.


Analogue inputs
For the analog inputs you can select from the measuring ranges 0..10V, 0..5V, +/- 10V or +/- 5V.

The A/D channels are scanned automatically at an adjustable interval.


Analogue outputs
Here you may set analog outputs in the measuring range 0..10V, 0..5V, +/- 10V or +/- 5V.


Settings
This picture shows the settings for analog outputs. Each channel can be given a name here.

It can also be defined here whether and at what interval the analog outputs are read back.

These settings are available for all I/Os.

 

Block diagram BS-Optoin

BS-Optoin

Counter / Flip-Flop Control

BS-Optoin Counter FF Ansteuerung

Connection example BS-Optoin

Anschlussbeispiel

Screwless connector system

The customer’s connection wiring of the inputs and outputs is carried out via screwless, pluggable terminal strips. The conductor connection is made by a so-called actuating tool.
A locking and ejection mechanism facilitates the insertion and removal of the complete terminal strip.

 

Handling

Step 1

Remove the operating tool from the scope of delivery.

Step 2

Insert the operating tool firmly into the side opening in the direction of conductor connection.

Step 3

Now insert the stripped conductor into the open terminal contact.

Schritt 4

Pull the operating tool out again.

Step 5

Check the correct connection of the conductor. It should now no longer be possible to pull it out easily.

DELIB driver library

Manual for the DELIB driver library
Documentation of all functions for the driver library
Download
  • Windows 10, 8, Vista, 7, XP, 2000 and Linux
  • module open/close functions
  • Digital Input read 1 / 8 / 16 / 32 / 64 bit
  • Digital Output write 1 / 8 / 16 / 32 / 64 bit
  • A/D Read, read_volt, read_mA, set A/D mode
  • D/A Write, write_volt, write_mA, set D/A mode

 

DELIB (32-bit) driver library for Windows
For Windows 10, Windows 7, Windows 8, Vista, XP und 2000
Download

Installation file for the 32 bit DELIB driver library.

The following operating systems are supported:

32 bit

  • Windows 10
  • Windows 7
  • Windows 8
  • Windows Server 2012
  • Windows Server 2008
  • Windows Vista
  • Windows XP
  • Windows Server 2003
  • Windows 2000

64 bit

  • Windows 10 x64
  • Windows 7 x64
  • Windows 8 x64
  • Windows Server 2012 x64
  • Windows Server 2008 x64
  • Windows Vista x64
  • Windows XP x64
  • Windows Server 2003 x64

Caution

With this version of the driver library, you can only compile 32 bit applications, which can be run on 32 and 64 systems.

 

DELIB (64-bit) driver library for Windows
For Windows 10, Windows 7, Windows 8, Vista, XP and 2000
Download

Installation file for the 64 bit DELIB driver library.

The following operating systems are supported:

64 bit

  • Windows 10 x64
  • Windows 7 x64
  • Windows 8 x64
  • Windows Server 2012 x64
  • Windows Server 2008 x64
  • Windows Vista x64
  • Windows XP x64
  • Windows Server 2003 x64

 

DELIB driver library for Linux (32/64-bit)
For 32/64-bit Linux distributions starting with kernel 2.6.x
Download

DELIB driver library for Linux distributions (32/64-bit) starting with kernel 2.6.x

This driver package includes the following components:

  • DELIB USB driver
  • DELIB Ethernet driver
  • DELIB CLI

DELIB USB driver

Supports the following products:

  • NET-Series (via USB interface)
  • RO-USB-Series
  • BS-USB-Series
  • USB-Mini-Sticks
  • USB-Watchdog
  • USB-OPTION-8 / USB-RELAIS-8
  • USB-TTL-32 / USB-TTL-64

Note:

With the standard USB driver, you can access several USB products with different module IDs (for example one RO-USB and one USB-OPTOIN-8). Therefore, no additional driver installation is required.

If you want to access several USB products with the same module ID (for example one USB-OPTOIN-8 and one USB-RELAIS-8), you have to install additionally the Linux FTDI driver. The FTDI driver can be found at http://www.ftdichip.com.

 

DELIB Ethernet driver

Supports the following products:

  • NET-Series (via Ethernet Interface)
  • RO-ETH-Series
  • RO-ETH/LC-Series
  • BS-ETH-Serie
  • ETH-OPTION-8 / ETH-RELAIS-8
  • ETH-TTL-64

DELIB CLI

With the DELIB CLI (Command Line Interface) for Linux it is possible so controll all I/O’s over the command-line.

 

DELIB - Sample-Sources - Installer (approx. 10 MB)
Sample programs for different programming languages (Also in DELIB Setup included)
Download

Sample programs for different programming languages (Also in DELIB Setup included)

  • C (Microsoft Visual C++ 6.0, Borland C)
  • C++ (Microsoft Visual C++ 6.0)
  • C# (Microsoft Visual C# 2008 to 2015)
  • Delphi (Borland Delphi 7)
  • VB (Microsoft Visual Basic 6.0)
  • VB.NET (Microsoft Visual Basic 2008 to 2015)
  • Java (Java native interface)
  • Java.dll (Ethernet protocol for ethernet products)

 

Manual protocol and register assignment
Transmission protocols and register assignment
Download

Describes the structure of the ethernet, serial and CAN protocol.
Includes a describtion for register access of the I/Os and access to the functions of a product.

 

Manual BS-Series
Hard- and Software-description
Download
  • Description of the control/regulation technology modules
  • Configuration of the different module interfaces
  • Software installation of the DELIB driver library

DEDITEC driver CD

DEDITEC Driver CD with many helpful tools and manuals for commissioning your DEDITEC products.

  • DELIB driver library for Windows
  • Test and configuration software
  • Manuals
  • Data sheets
  • Example programs for C++, C#, VB, VB.Net, Delphi, LabVIEW

2 pin plug connector

Allows the power supply to be connected to the DEDITEC module

  • Type: Phoenix Contact 1783287
  • 100 % malfunction protected
  • For all conductor types from 0.2mm² to 2.5mm²

16 pol connector

Required to connect your application to the DEDITEC module

  • Type: Wago Kontakttechnik 713-1108/037-000
  • Pluggable female connector with locking mechanism
  • 100 % malfunction protected
  • 1-wire connection for all types of conductors up to 1.5mm²

Tool for wiring connectors

Serves to open and close the clamp contacts on the Wago connectors.
  • Type: Wago Kontakttechnik 734-231

2 meter USB A/B connection cable

2 meter USB connection cable A to B.

  • Type: Plug A to plug B
  • length: 1,8m

Optional input voltage range 5V..15V DIL

With this option the input voltage range of the BS-OPTOIN modules can be reduced to 5..15V. We will always modify 8 channels per ordered quantity.

  • Input voltage range 5V to 15V AC / DC
  • 8 channels

USB watchdog stick with 2 relays for shift operations

This USB-WATCHDOG-STICK monitors your operating PC or server and can reset the hardware independently in case of a program crash. Simply integrate the function of the Watchdog Stick into your application. As soon as a timeout occurs and the watchdog stick is no longer periodically reset, the two relay outputs are switched through. With an appropriate connection cabling, for example, the PC reset could be activated, an external SMS modem can send warnings or a connected siren signals an alarm. With the help of our free configuration tool, you can define how the relays should switch in case of an error.

  • USB 2.0 / USB 1.1 interface
  • Watchdog function
  • Monitoring your control PC or server
  • Timeout times adjustable from 10ms to 10h
  • Windows Watchdog API
  • 2 NO contact relay (NO)
  • Connection cable with DSUB9 socket (approx. 1.8m)

Power supply 24V/2A for DIN rail mounting

The DR-4524 from Mean Well is a 48W rail mount power supply for industrial applications. It offers protection against short circuit, overload, overvoltage and overheating.

  • Input voltage range: 85V… 264V AC / 120V DC … 370V DC
  • Output voltage: 24V DC
  • Output current: 2A
  • Nominal power: 48W

230V din rail relay

With this 230V relay can you reduce your voltage to 12V. The 12V signal can be read by our opto coupler inputs.

  • Max switching current 250V AC
  • Coil current 4,5mA

DIN rail 1m



Top-hat rail for mounting our control technology modules.

  • Top-hat rail according to DIN EN 50022
  • Type: Phoenix Contact / 1208131
  • Dimensions in mm: 450 x 35 x 7.5 (L x W x D)

2 pin plug connector

Allows the power supply to be connected to the DEDITEC module

  • Type: Phoenix Contact 1783287
  • 100 % malfunction protected
  • For all conductor types from 0.2mm² to 2.5mm²

16 pol connector

Required to connect your application to the DEDITEC module

  • Type: Wago Kontakttechnik 713-1108/037-000
  • Pluggable female connector with locking mechanism
  • 100 % malfunction protected
  • 1-wire connection for all types of conductors up to 1.5mm²

Tool for wiring connectors

Serves to open and close the clamp contacts on the Wago connectors.
  • Type: Wago Kontakttechnik 734-231

Reviews

There are no reviews yet.

Be the first to review “BS-ETH-USB module with 32/64 optocoupler inputs”

Your email address will not be published. Required fields are marked *