Ethernet Modul mit 32 Optokoppler-Eingängen und 32 MOSFET Ausgängen

BS-ETH-O32-M32

Produkt-Highlights

  • Ethernet-Interface mit galvanischer Trennung
  • 32 digitale Optokoppler-Eingänge
  • 15 - 30V AC/DC Eingangsspannung (optional 5 - 15V AC/DC)
  • Galvanisch getrennt über Optokoppler
  • 16 Bit Zähler (bis 100Hz) / Flipflop je Kanal
  • 32 MOSFET Ausgänge (30V/2A/60W DC) (Optokoppler gesteuert)
  • LED-Zustandsanzeige je Ausgangskanal
  • Timeout-Ausgangsschutz per Software konfigurierbar
  • Galvanische Trennung über Optokoppler
  • Robustes Aluminiumgehäuse, für Hutschienenmontage geeignet
Einkaufswagen
€ 691,39
Preise inkl. gesetzl. MwSt. | zzgl. Versandkosten

Versandkosten


close

Versandkosten / Shipping Costs



Genannte Versandkosten beziehen sich auf Sendungen bestehend aus einem Paket mit einem Gewicht bis zu 2kg.

Mentioned shipping costs are calculated for one package with a weight up to 2kg.

If your country is not listet in the table below, please do not hesitate to contact us regarding shipping to your desired destination.

Land Price EUR Duration Express EUR Duration Express
Deutschland 6,90 1-3 day(s) 19,90 1 day
Belgium 12,00 1-3 day(s) 25,00 1 day
Luxembourg 12,00 1-3 day(s) 25,00 1 day
Netherlands 12,00 1-3 day(s) 25,00 1 day
Czech republic 12,00 1-3 day(s) 25,00 1 day
Poland 16,50 1-3 day(s) 29,00 1 day
Slovakia 16,50 1-3 day(s) 29,00 1 day
Slovenia 16,50 1-3 day(s) 29,00 1 day
Denmark 25,00 1-3 day(s) 38,00 1 day
Finland 25,00 1-3 day(s) 38,00 1 day
France 25,00 1-3 day(s) 38,00 1 day
Britain 25,00 1-3 day(s) 38,00 1 day
Austria 25,00 1-3 day(s) 38,00 1 day
Sweden 25,00 1-3 day(s) 38,00 1 day
Italy 25,00 1-3 day(s) 38,00 1 day
Bulgaria 21,00 1-3 day(s) 34,00 1 day
Estonia 21,00 1-3 day(s) 34,00 1 day
Latvia 21,00 1-3 day(s) 34,00 1 day
Lithuania 21,00 1-3 day(s) 34,00 1 day
Romania 21,00 1-3 day(s) 34,00 1 day
Hungary 21,00 1-3 day(s) 34,00 1 day
Greece 24,00 1-3 day(s) 37,00 1 day
Ireland 24,00 1-3 day(s) 37,00 1 day
Spain 24,00 1-3 day(s) 37,00 1 day
Liechtenstein 30,00 1-3 day(s) 43,00 1 day
Norway 30,00 1-3 day(s) 43,00 1 day
Switzerland 30,00 1-3 day(s) 43,00 1 day
San Marino 30,00 1-3 day(s) 43,00 1 day
Bosnia-Herzegovina 71,00 1-3 day(s) 84,00 1 day
Russia 71,00 1-3 day(s) 84,00 1 day
Turkey 71,00 1-3 day(s) 84,00 1 day
Canada 65,00 1-3 day(s) 78,00 1 day
United States of America 65,00 1-3 day(s) 78,00 1 day
Mexico 67,00 1-3 day(s) 80,00 1 day
Puerto Rico 67,00 1-3 day(s) 80,00 1 day
Brazil 99,00 1-3 day(s) 112,00 1 day
South Africa 109,00 1-3 day(s) 122,00 1 day
United Arab Emirates 109,00 1-3 day(s) 122,00 1 day
Australia 99,00 1-3 day(s) 112,00 1 day
China 88,00 1-3 day(s) 101,00 1 day
Hong Kong 88,00 1-3 day(s) 101,00 1 day
India 88,00 1-3 day(s) 101,00 1 day
Portugal 24,00 1-3 day(s) 37,00 1 day
Japan 88,00 1-3 day(s) 101,00 1 day


Genannte Laufzeiten sind immer ca. Werte.

Mentioned durations are always approximate values.

close

Verwandte Themen

Interessantes

Mit 400 MHz Linux Power können eigene Anwendungen direkt im Modul ausgeführt werden

Zubehör

Passende Zubehörartikel für dieses Produkt

Unser Unternehmen:

Inhaltsverzeichnis

Beschreibung
Software
Technische Daten
Konfiguration
Lieferumfang
Blockschaltbilder
Anschlussbeispiele
DELIB-API Befehle
Steckverbinder
Zubehör
APP
WEB-Oberfläche
Downloads
Online Manuals

Beschreibung

BS-Serie

Die Produkte der BS-Serie verfügen über eine kleine und große Anzahl an digitalen Ein-/Ausgängen und sind mit verschiedenen Schnittstellen verfügbar. Egal, ob Sie mit unserer DELIB-API oder über unsere offenen Protokolle mit dem Produkt kommunizieren möchten, Sie behalten die Kontrolle.

Ethernet-Interface

Unsere Ethernet Produkte sind für den industriellen Einsatz zur Messung, Steuerung und Regelung entwickelt worden. Die Kommunikation über Ethernet ermöglicht eine sehr hohe weltweite Verfügbarkeit. Unsere DELIB API bietet eine einfache Programmierschnittstelle für Ihre eigenen Softwareapplikation. Eine direkte Kommunikation über unser Ethernet-Protokoll ist ebenso möglich.

Interface und galvanische Trennung

Das Produkt verfügt über ein 100/10 Mbit/s Schnittstelle mit galvanischer Trennung des Interfaces. Das Konzept der galvanischen Trennung verhindert, dass Störungen und Spannungsspitzen übertragen werden. Das robuste Aluminiumgehäuse ist für die Montage auf einer Hutschiene geeignet.

Spannungsversorgung

Die Spannungsversorgung des Produkts erfolgt über ein 12V bis 24V DC Netzteil. Ein passendes Hutschienennetzteil kann unter Zubehör bestellt werden.

I/O-Control App für Android - I/O-Control für Android Smartphones

Status-LEDs

Das Ethernet-Interface verfügt über 6 Status-LEDs. Eine Power-LED zur Anzeige der Spannungsversorgung. Anhand der Interface-Activity LED kann abgelesen werden, ob eine Kommunikation über die Ethernet-Schnittstelle stattfindet. Die Error-LED leuchtet im Falle eines Fehlers. Die Input-Change LED zeigt einen Wechsel der Eingangssignale an. Die Timeout-LED signalisiert das Auslösen der Timeout-Schutzfunktion. Einen Zugriff auf die digitalen Ein-/Ausgänge kann man anhand der I/O-Access-LED erkennen.


Digitale Eingänge (Optokoppler)

Die BS-Serie bietet mit ihren Eingabemodulen die Möglichkeit, digitale Signale zu erfassen. Ob ein Signal an einem Eingang anliegt, kann jederzeit abgefragt werden. Auch das gleichzeitige Auslesen von bis zu 64 digitalen Eingängen wird von der DELIB Treiberbibliothek unterstützt.

Spannungsbereiche und Zustands-LED

Der Standard Eingangsspannungsbereich der Eingänge ist 15 - 30V DC/AC. Liegt ein Signal mit mindestens 15V an einem Eingang an, wird der Status des Eingangs als logische 1 wiedergegeben. Fällt das Eingangssignal ab, wird der Status des Eingangs als logische 0 wiedergegeben. Jeder Eingang verfügt über eine Leuchtdiode (LED), die den logischen Zustand eines Eingangs anzeigt

Optional: Der Eingangspannungsbereich 5 - 15V DC/AC ist als Zubehör bestellbar.

Galvanische Trennung & Anschlussverdrahtung

Durch die Verwendung von Optokopplern sind alle digitalen Eingänge untereinander, sowie zum Interface galvanisch getrennt. Bei der Anschlussverdrahtung muss bei den Optokoppler-Eingängen nicht auf die Polarität geachtet werden.

Zählfunktion

Jeder digitale Eingang verfügt über einen eigenen 16-Bit Zähler. Der Zählerstand eines Eingangs kann separat ausgelesen und zurückgesetzt werden. Wird der maximale Zählerstand von 65535 überschritten, wird der Zähler automatisch auf 0 zurückgesetzt.

Status-LEDs

Des Weiteren verfügt jeder Eingang über einen Eingangszustandsmerker (Flipflop). Durch den Eingangszustandsmerker können auch schnelle Impulse zwischen zwei Auslesezyklen zuverlässig erfasst werden. Der Eingangszustandsmerker kann ebenfalls wie beim Zähler für jeden digitalen Eingang separat ausgelesen werden. Der Eingangszustandsmerker wird automatisch nach dem Auslesen zurückgesetzt.


Digitale Ausgänge (MOSFET)

Die MOSEFT-Ausgänge der BS-Serie können bis zu 30V DC/AC transportieren. Die Ausgänge können separat, aber auch bis zu 64 Ausgänge gleichzeitig, per Software geschaltet werden. Der Zustand eines MOSFET-Ausgangs kann logisch 0 oder 1 annehmen. Bei einer logischen 1 schaltet das MOSFET die angeschlossene Spannung durch.

Zustands-LED & galvanische Trennung

Jeder Ausgang verfügt über eine Leuchtdiode (LED), die den logischen Zustand des Ausgangs anzeigt. Jeweils 8 MOSFET-Ausgänge (ein Steckverbinder) teilen sich eine Spannungszufuhr sowie Masse. Dieser Zusammenschluss von 8 Ausgängen ist gegenüber anderen Ein-/Ausgängen sowie zum Interface galvanisch getrennt.

Timeout-Abschaltung

Per Software-Befehl lässt sich eine Timeout-Schutzfunktion für die MOSFET Ausgänge aktivieren. Im Falle eines Fehlers, beispielsweise bei einem Kommunikationsproblem mit einem Steuer-PC, wird der Zustand der MOSFETs automatisch logisch auf 0 gesetzt und somit keine angeschlossenen Signale mehr geschaltet. Die Zeitspanne bis zum Auslösen des Timeouts wird beim Aktivieren des Timeouts festgelegt. Die Zeitspanne kann in 100 Millisekunden Schritten eingestellt werden. Ob der Timeout aktiv oder inaktiv ist, kann per Software ausgelesen werden. Wurde der Timeout ausgelöst, kann dies ebenfalls per Software ausgelesen werden. Zusätzlich wird das Auslösen des Timeouts mit einer LED am Interface des Produkts signalisiert.


Steckverbinder

Die im Lieferumfang enthaltenen Steckverbinder verfügen über ein schraubenloses Stecksystem und ermöglichen eine schnelle und unkomplizierte Anschlussverdrahtung. Angeschlossene Kabel werden durch einee Klemme sicher gehalten. Zum lösen der Klemmen liegt entsprechendes Werkzeug bei. Ein Auswurfmechanismus ermöglicht ein schnelles Wechseln der Steckverbinder.

Hinweis: Zusätzliche Steckverbinder können als Zubehör bestellt werden.


Software

Ansteuerung der Ethernet-Module

Unsere Ethernet-Module können über zwei Wege angesteuert werden.

1. Über unsere mitgelieferte Windows Treiberbibliothek DELIB

Diese ermöglicht ein direktes Ansprechen der Produkte. Um das TCP-I/P Protokoll müssen Sie sich nicht kümmern. Das übernimmt unsere Treiberbibliothek für Sie!

2. Sie programmieren die Ansteuerung selber

Das entsprechende Protokoll steht im Bereich Download bereit. So können unsere Produkte Plattformunabhängig von kleinen Linux-Rechnern bis hin zu Laborplätzen angeschlossen werden, die über ein Ethernet Interface verfügen.

Ansteuerung über unsere DELIB Treiberbibliothek unter Windows

Die umfangreiche und dennoch sehr einfach zu bedienende Library ist für nahezu jede Programmiersprachen geeignet. Über eine mitgelieferte DLL kann jede Funktion angesprochen werden. Fertige Beispiele im Quelltext für Programmiersprachen C, Delphi oder Visual Basic und viele weitere Sprachen finden Sie im Download Bereich.

Beispiel für das Ansprechen unserer Produkte in "C"

Mit dem folgenden Beispiel zeigen wir Ihnen in "C", wie mit einfachen Mitteln innerhalb kürzester Zeit auf die Eingänge unserer Module zugegriffen werden kann.

1. Schritt: Öffnen des gewünschten Moduls

handle = DapiOpenModule(RO_ETH,0); // Ethernet-Modul öffnen

2. Schritt: Lesen von 16 digitalen Eingängen

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

3. Schritt: Modul wieder schließen

DapiCloseModule(handle); // Close the module


Die Funktion "DapiOpenModule" dient zum Öffnen eines speziellen Moduls. Welches Modul geöffnet werden soll, das bestimmen die beiden übergebenen Parameter. Der erste Parameter bezeichnet die "Modul-ID. Durch die eingebundene "DELIB.H" kann der Parameter einfach mit "RO_ETH" angegeben werden. So wird der Treiberbibliothek mitgeteilt, dass ein RO-Modul mit Ethernet-Schnittstelle angesprochen werden soll.

Der zweite Parameter bestimmt die Modul-Nummer. Ist nur ein Modul am PC angeschlossen, dann wird einfach die "0" angegeben. Sind mehrere Module angeschlossen muss die entsprechende Nummer des Moduls angegeben werden. Die Verweise auf die entsprechende IP-Adresse des Moduls werden mit dem "DELIB-Konfigurations Utility" konfiguriert.

Bild klicken um zu vergrössern

Vergrößerte Ansicht

DT-Module Demo

Im Lieferumfang enthalten ist die DT-Module Demo. Dieses Programm erlaubt einen schnellen Zugriff auf die I/Os eines DEDITEC Produktes. In diesen Beispiel ist ein RO-ETH angeschlossen. Das angeschlossene RO-ETH verfügt PT100 Temperatursensoren, Relais Ausgängen und Schrittmotorsteuerungen.

Ansteuerung über unser offengelegtes Ethernet Protokoll

Bei Bedarf können Sie Ihre eigene Ansteuerung selber programmieren. Das Protokoll hierfür, welches die Kommunikation über TCP-IP beschreibt, ist offengelegt. Die Ansteuerung erfolgt registerbasiert. Hierfür wurde ein offenes Kommunikations-Protokoll erstellt, anhand dessen die Register des Moduls angesprochen werden und somit Lese- oder Schreibbefehle ausgeführt werden. Das Handbuch Ethernet Übertragungsprotokoll beschreibt die Sende- und Empfangsrahmen um mit unseren Ethernet-Modulen zu kommunizieren.

Hier gehts zur Dokumentation des Ethernet-Protokollsweiter

Technische Daten

Ethernet-Interface

Interface 100/10 Mbit Ethernet (galvanisch getrennt)
Konfiguration über das DELIB Configuration Utility (IP-Adr., Netzmaske ...)
IP-Adresse IP-Adresse kann über DHCP bezogen oder statisch vergeben werden

Optokoppler Eingangsmodul

Elektrische Daten: 32 Optokoppler Eingänge
15V - 24V DC/AC Signalspannung (optional 5V - 15V DC/AC)
Isolationsspannung: 2,5KV AC für 1 Minute
Maximaler Eingangsstrom: 10mA
Eingangszustandmerker (Flip-Flops): Erkennt einen Wechsel von Low auf High und High auf Low Pegel
Erfasst die Eingangszustandsänderung zwischen zwei Auslesevorgängen
Eingangszustandmerker wird beim Auslesen resettet
Eingangszähler: 16 Bit Zähler je Kanal
Maximal mögliche Zählvorgänge: 65535 / Kanal
Nach Speicherüberlauf Reset auf 0
Interne Zähllogik bis 100Hz
Programmierbarer Filter für Eingangskanäle (Flip-Flop und Counter):
Mindest low bzw. high Impulsdauer: 5ms...255ms
LED's: Je eine LED pro Eingangskanal
Steckverbinder: Steckbare 16 polige Klemmleiste für jeweils 8 Eingänge

Optokoppler Ausgangsmodul

Elektrische Daten: 32 Optokoppler gesteuerte MOSFET Ausgänge
Max. Schaltstrom: 2A DC
Min. Schaltspannung: 2.8V DC
Max. Schaltspannung: 30V DC
Max. Schaltleistung: 60W DC
Max. Transportstrom: 2A DC
Timeout-Funktion Folgende Befehle stehen für den Timeout-Schutz per Software zur Verfügung:
- aktivierbar/deaktivierbar
- Zeitraum setzten
- Konfiguration des Timeout-Schutzes lesen
- Zustand des Timeout-Schutzes lesen (aktiv, nicht aktiv, ausgelöst)
LED's: Je eine LED pro Ausgangskanal
Steckverbinder: Steckbare 16 polige Klemmleiste für jeweils 8 Ausgänge

Generelles

Abmessungen 230 mm x 105 mm x 74,5 mm (LxBxH)

Konfiguration

Konfiguration der Ethernet-Schnittstelle

Die gesamten Netzwerkeinstellungen können über das DELIB Configuration Utility vorgenommen werden. Das DELIB Configuration Utility wird mit der DELIB 2.0 Treiberbibliothek installiert. Die Software ist im Lieferumfang enthalten sowie als Download verfügbar.

DELIB 2.0 Treiberbibliothek

Konfigurierbare Parameter

Die folgenden Parameter können mithilfe des DELIB Configuration Utilitys geändert werden:
  • Board Name (DHCP)
  • DHCP oder statische IP
  • IP-Adresse
  • Netzmaske
  • Std.-Gateway
  • Port
  • Verbindungstimeout
  • Verschlüsselung
  • Namensvergabe für I/Os

Netzübergreifende Suche nach DEDITEC Produkten

Mit dem DELIB Configuration Utilitys lässt sich das Netzwerk automatisch nach DEDITEC Produkten durchsuchen. Alle gefundenen Produkte lassen sich mit wenigen Klicks konfigurieren.

Auch Produkte mit nicht konfigurierten Netzwerkeinstellungen können anhand des sehr einfach zu bedienenden Utilities gefunden und konfiguriert werden.

Bild klicken um zu vergrössern

Vergrößerte Ansicht

DELIB Configuration Utiliy

Übersicht aller DEDITEC Produkte im Netzwerk und den Basis Einstellungsmöglichkeiten

Erweiterte Optionen

Ansicht der erweiterten Einstellungsmöglichkeiten für Netzwerkeinstellungen, Verschlüsselung und Namensvergabe für I/Os

Bild klicken um zu vergrössern

Vergrößerte Ansicht

Bild klicken um zu vergrössern

Vergrößerte Ansicht

Port und Timeout

Zusätzliche Optionen für den Verbindungstimeout und den verwendeten Port können festgelegt werden.

Verschlüsselungsoptionen

Falls erwünscht, kann eine gesicherte Verbindung mit Benutzername und Passwort eingerichtet werden.

Bild klicken um zu vergrössern

Vergrößerte Ansicht

Bild klicken um zu vergrössern

Vergrößerte Ansicht

I/O Namensvergabe

Es besteht die Möglichkeit I/Os zu benennen. Diese Funktion erleichtert den Umgang mit den I/Os und dient dem Komfort. Diese Funkion ist nur bei Produkten mit Ethernet-Schnittstelle vorhanden

Lieferumfang

DEDITEC Treiber CD

DEDITEC Treiber CD

Die DEDITEC Treiber CD enthält alle benötigten Treiber und Programme zur Inbetriebnahme unserer Produkte.

Zweipoliger gewinkelter Steckverbinder

Zweipoliger gewinkelter Steckverbinder

Der 2 polige Steckverbinder ermöglicht eine saubere Verkabelung der Spannungsversorgung.

16 poliger Steckverbinder mit Auswerfmechanik

16 poliger Steckverbinder mit Auswerfmechanik

Unsere Steckverbinder bieten einen einfachen und sicheren Anschluss an unsere Module. Durch die integrierte Schraubverriegelung ist das nachträgliche Austauschen der angeschlossenen Module möglich.

Hilfswerkzeug für Anschlussklemmen

Hilfswerkzeug für Anschlussklemmen

Mit diesem Werkzeug werden die Anschlussklemmen der Steckverbinder geöffnet. Wurde die Verkabelung durchgeführt, wird mit dem entfernen des Werkzeuges die Anschlussklemme wieder geschlossen.

Blockschaltbilder

Blockschaltbild BS-Optoin


BS-Optoin

Counter / Flip-Flop Ansteuerung


BS-Optoin Counter FF Ansteuerung

Blockschaltbild BS-MOSFET


BS-MOSFET

Anschlussbeispiele

Anschlussbeispiel BS-Optoin


Anschlussbeispiel

Anschlussbeispiel BS-MOSFET


Anschlussbeispiel

DELIB-API Befehle


Verwaltungsfunktionen

DapiOpenModule

Diese Funktion öffnet ein bestimmtes Modul

close

DapiOpenModule

Beschreibung

Diese Funktion öffnet ein bestimmtes Modul

Definition

ULONG DapiOpenModule(ULONG moduleID, ULONG nr);

Parameter

moduleID=Gibt das Modul an, welches geöffnet werden soll (siehe delib.h)
nr=Gibt an, welches (bei mehreren Modulen) geöffnet werden soll.
nr=0 -> 1. Modul
nr=1 -> 2. Modul


Return-Wert

handle=Entsprechender Handle für das Modul
handle=0 -> Modul wurde nicht gefunden

Bemerkung

Der von dieser Funktion zurückgegebe Handle wird zur Identifikation des Moduls für alle anderen Funktionen benötigt.

Programmierbeispiel

// USB-Modul öffnen
handle = DapiOpenModule(RO_USB1, 0);
printf("handle = %x\n", handle);
if (handle==0)
{
// USB Modul wurde nicht gefunden
printf("Modul konnte nicht geöffnet werden\n");
return;
}

DapiCloseModule

Dieser Befehl schliesst ein geöffnetes Modul.

close

DapiCloseModule

Beschreibung

Dieser Befehl schliesst ein geöffnetes Modul.

Definition

ULONG DapiCloseModule(ULONG handle);

Parameter

handle=Dies ist das Handle eines geöffneten Moduls


Return-Wert

Keiner

Programmierbeispiel

// Modul schliessen
DapiCloseModule(handle);

DapiGetLastError

Diese Funktion liefert den letzten erfassten Fehler. Sofern ein Fehler aufgetreten ist, muss dieser mit DapiClearLastError() gelöscht werden, da sonst jeder Aufruf von DapiGetLastError() den "alten" Fehler zurückgibt. Sollen mehrere Module verwendet werden, empfielt sich die Verwendung von DapiGetLastErrorByHandle().

close

DapiGetLastError

Beschreibung

Diese Funktion liefert den letzten erfassten Fehler. Sofern ein Fehler aufgetreten ist, muss dieser mit DapiClearLastError() gelöscht werden, da sonst jeder Aufruf von DapiGetLastError() den "alten" Fehler zurückgibt.
Sollen mehrere Module verwendet werden, empfielt sich die Verwendung von DapiGetLastErrorByHandle().

Definition

ULONG DapiGetLastError(void);

Parameter

Keine


Return-Wert

Fehler Code
0=kein Fehler. (siehe delib_error_codes.h)

Programmierbeispiel

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

Diese Funktion liefert den letzten erfassten Fehler eines bestimmten Moduls (handle). Sofern ein Fehler aufgetreten ist, muss dieser mit DapiClearLastErrorByHandle() gelöscht werden, da sonst jeder Aufruf von DapiGetLastErrorByHandle() den "alten" Fehler zurückgibt.

close

DapiGetLastErrorByHandle

Beschreibung

Diese Funktion liefert den letzten erfassten Fehler eines bestimmten Moduls (handle). Sofern ein Fehler aufgetreten ist, muss dieser mit DapiClearLastErrorByHandle() gelöscht werden, da sonst jeder Aufruf von DapiGetLastErrorByHandle() den "alten" Fehler zurückgibt.

Definition

ULONG DapiGetLastErrorByHandle(ULONG handle);

Parameter

handle=Dies ist das Handle eines geöffneten Moduls


Return-Wert

Fehler Code
0=kein Fehler. (siehe delib_error_codes.h)

Programmierbeispiel

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

Diese Funktion liest den Text des letzten erfassten Fehlers. Sofern ein Fehler aufgetreten ist, muss dieser mit DapiClearLastError() gelöscht werden, da sonst jeder Aufruf von DapiGetLastErrorText() den "alten" Fehler zurückgibt.

close

DapiGetLastErrorText

Beschreibung

Diese Funktion liest den Text des letzten erfassten Fehlers. Sofern ein Fehler aufgetreten ist, muss dieser mit DapiClearLastError() gelöscht werden, da sonst jeder Aufruf von DapiGetLastErrorText() den "alten" Fehler zurückgibt.

Definition

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

Parameter

msg = Buffer für den zu empfangenden Text
msg_length = Länge des Text Buffers


Programmierbeispiel

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

Diese Funktion löscht den letzten Fehler, der mit DapiGetLastError() erfasst wurde.

close

DapiClearLastError

Beschreibung

Diese Funktion löscht den letzten Fehler, der mit DapiGetLastError() erfasst wurde.

Definition

void DapiGetLastError(void);

Parameter

Keine


Return-Wert

Keine

Programmierbeispiel

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

Diese Funktion löscht den letzten Fehler eines bestimmten Moduls (handle), der mit DapiGetLastErrorByHandle() erfasst wurde.

close

DapiClearLastErrorByHandle

Beschreibung

Diese Funktion löscht den letzten Fehler eines bestimmten Moduls (handle), der mit DapiGetLastErrorByHandle() erfasst wurde.

Definition

void DapiClearLastErrorByHandle(ULONG handle);

Parameter

handle=Dies ist das Handle eines geöffneten Moduls


Return-Wert

Keine

Programmierbeispiel

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

Diese Funktion gibt die installierte DELIB-Version zurück.

close

DapiGetDELIBVersion

Beschreibung

Diese Funktion gibt die installierte DELIB-Version zurück.

Definition

ULONG DapiGetDELIBVersion(ULONG mode, ULONG par);

Parameter

mode=Modus, mit dem die Version ausgelesen wird (muss immer 0 sein).
par=Dieser Parameter ist nicht definiert (muss immer 0 sein).


Return-Wert

version=Versionsnummer der installierten DELIB-Version [hex]

Programmierbeispiel

version = DapiGetDELIBVersion(0, 0);
//Bei installierter Version 1.32 ist version = 132(hex)

Spezial-Funktionen

DapiSpecialCommand - DapiSpecialCMDGetModuleConfig

Diese Funktion gibt die Hardwareaustattung (Anzahl der Ein- bzw. Ausgangskanäle) des Moduls zurück.

close

DapiSpecialCommand - DapiSpecialCMDGetModuleConfig

Beschreibung

Diese Funktion gibt die Hardwareaustattung (Anzahl der Ein- bzw. Ausgangskanäle) des Moduls zurück.

Definition

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

Parameter

handle=Dies ist das Handle eines geöffneten Moduls

Anzahl der digitalen Eingangskanäle abfragen
par=DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_DI

Anzahl der digitalen Ausgangskanäle abfragen
par=DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_DO

Anzahl der digitalen Ein-/Ausgangskanäle abfragen
par=DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_DX

Anzahl der analogen Eingangskanäle abfragen
par=DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_AD

Anzahl der analogen Ausgangskanäle abfragen
par=DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_DA

Anzahl der Stepperkanäle abfragen
par=DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_STEPPER


Return-Wert

Anzahl der digitalen Eingangskanäle abfragen
return=Anzahl der digitalen Eingangskanäle

Anzahl der digitalen Ausgangskanäle abfragen
return=Anzahl der digitalen Ausgangskanäle

Anzahl der digitalen Ein-/Ausgangskanäle abfragen
return=Anzahl der digitalen Ein-/Ausgangskanäle

Anzahl der analogen Eingangskanäle abfragen
return=Anzahl der analogen Eingangskanäle

Anzahl der analogen Ausgangskanäle abfragen
return=Anzahl der analogen Ausgangskanäle

Anzahl der Stepperkanäle abfragen
return=Anzahl der Stepperkanäle

Programmierbeispiel

ret=DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_GET_MODULE_CONFIG, DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_DI, 0, 0);
//Gibt die Anzahl der digitalen Eingangskanäle zurück
ret=DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_GET_MODULE_CONFIG, DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_DO, 0, 0);
//Gibt die Anzahl der digitalen Ausgangskanäle zurück
ret=DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_GET_MODULE_CONFIG, DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_DX, 0, 0);
//Gibt die Anzahl der digitalen Ein-/Ausgangskanäle zurück
ret=DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_GET_MODULE_CONFIG, DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_AD, 0, 0);
//Gibt die Anzahl der analogen Eingangskanäle zurück
ret=DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_GET_MODULE_CONFIG, DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_DA, 0, 0);
//Gibt die Anzahl der analogen Ausgangskanäle zurück
ret=DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_GET_MODULE_CONFIG, DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_STEPPER, 0, 0);
//Gibt die Anzahl der Stepperkanäle zurück

Digitale Eingabe-Funktionen

DapiDIGet1

Dieser Befehl liest einen einzelnen digitalen Eingang.

close

DapiDIGet1

Beschreibung

Dieser Befehl liest einen einzelnen digitalen Eingang.

Definition

ULONG DapiDIGet1(ULONG handle, ULONG ch);

Parameter

handle=Dies ist das Handle eines geöffneten Moduls
ch=Gibt die Nummer des Eingangs an, der gelesen werden soll (0, 1, 2, 3, .. )


Return-Wert

Zustand des Eingangs (0/1)

Requirements

Die folgenden SW-Feature-Bits müssen vom Modul unterstützt werden:

DAPI_SW_FEATURE_BIT_CFG_DI

Die Folgenden Bedingungen für die Übergabeparameter müssen eingehalten werden:

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

DapiDIGet8

Dieser Befehl liest gleichzeitig 8 digitale Eingänge.

close

DapiDIGet8

Beschreibung

Dieser Befehl liest gleichzeitig 8 digitale Eingänge.

Definition

ULONG DapiDIGet8(ULONG handle, ULONG ch);

Parameter

handle=Dies ist das Handle eines geöffneten Moduls
ch=Gibt die Nummer des Eingangs an, ab dem gelesen werden soll (0, 8, 16, 24, .. )


Return-Wert

Zustand der gelesen Eingänge

Requirements

Die folgenden SW-Feature-Bits müssen vom Modul unterstützt werden:

DAPI_SW_FEATURE_BIT_CFG_DI

Die Folgenden Bedingungen für die Übergabeparameter müssen eingehalten werden:

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

Dieser Befehl liest gleichzeitig 16 digitale Eingänge.

close

DapiDIGet16

Beschreibung

Dieser Befehl liest gleichzeitig 16 digitale Eingänge.

Definition

ULONG DapiDIGet16(ULONG handle, ULONG ch);

Parameter

handle=Dies ist das Handle eines geöffneten Moduls
ch=Gibt die Nummer des Eingangs an, ab dem gelesen werden soll (0, 16, 32, ...)


Return-Wert

Zustand der gelesen Eingänge

Requirements

Die folgenden SW-Feature-Bits müssen vom Modul unterstützt werden:

DAPI_SW_FEATURE_BIT_CFG_DI

Die Folgenden Bedingungen für die Übergabeparameter müssen eingehalten werden:

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

Dieser Befehl liest gleichzeitig 32 digitale Eingänge.

close

DapiDIGet32

Beschreibung

Dieser Befehl liest gleichzeitig 32 digitale Eingänge.

Definition

ULONG DapiDIGet32(ULONG handle, ULONG ch);

Parameter

handle=Dies ist das Handle eines geöffneten Moduls
ch=Gibt die Nummer des Eingangs an, ab dem gelesen werden soll (0, 32, 64, ..)


Return-Wert

Zustand der gelesen Eingänge

Requirements

Die folgenden SW-Feature-Bits müssen vom Modul unterstützt werden:

DAPI_SW_FEATURE_BIT_CFG_DI

Die Folgenden Bedingungen für die Übergabeparameter müssen eingehalten werden:

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

Programmierbeispiel

unsigned long data;
// ----------------------------------------------------
// Einen Wert von den Eingängen lesen (Eingang 1-31)
data = (unsigned long) DapiDIGet32(handle, 0);
// Chan Start = 0
printf("Eingang 0-31 : 0x%x\n", data);
printf("Taste für weiter\n");
getch();
// ----------------------------------------------------
// Einen Wert von den Eingängen lesen (Eingang 32-64)
data = (unsigned long) DapiDIGet32(handle, 32);
// Chan Start = 32
printf("Eingang 32-64 : 0x%x\n", data);
printf("Taste für weiter\n");
getch();

DapiDIGet64

Dieser Befehl liest gleichzeitig 64 digitale Eingänge.

close

DapiDIGet64

Beschreibung

Dieser Befehl liest gleichzeitig 64 digitale Eingänge.

Definition

ULONGLONG DapiDIGet64(ULONG handle, ULONG ch);

Parameter

handle=Dies ist das Handle eines geöffneten Moduls
ch=Gibt die Nummer des Eingangs an, ab dem gelesen werden soll (0, 64, ..)


Return-Wert

Zustand der gelesen Eingänge

Requirements

Die folgenden SW-Feature-Bits müssen vom Modul unterstützt werden:

DAPI_SW_FEATURE_BIT_CFG_DI

Die Folgenden Bedingungen für die Übergabeparameter müssen eingehalten werden:

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

Dieser Befehl liest die Flip-Flops der Eingänge aus und setzt diese zurück. (Eingangszustands-Änderung)

close

DapiDIGetFF32

Beschreibung

Dieser Befehl liest die Flip-Flops der Eingänge aus und setzt diese zurück.
(Eingangszustands-Änderung)

Definition

ULONG DapiDIGetFF32(ULONG handle, ULONG ch);

Parameter

handle=Dies ist das Handle eines geöffneten Moduls
ch=Gibt die Nummer des Eingangs an, ab dem gelesen werden soll (0, 32, 64, ..)


Return-Wert

Zustand von 32 Eingangszustandsänderungen

Requirements

Die folgenden SW-Feature-Bits müssen vom Modul unterstützt werden:

DAPI_SW_FEATURE_BIT_CFG_DI_FF

Die Folgenden Bedingungen für die Übergabeparameter müssen eingehalten werden:

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

DapiDIGetCounter

Dieser Befehl liest den Eingangszähler eines digitalen Eingangs.

close

DapiDIGetCounter

Beschreibung

Dieser Befehl liest den Eingangszähler eines digitalen Eingangs.

Definition

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

Parameter

handle=Dies ist das Handle eines geöffneten Moduls.
ch=Gibt die Nummer des Eingangs an, ab dem gelesen werden soll.
mode=0 (Normale Zählfunktion)
mode=DAPI_CNT_MODE_READ_WITH_RESET (Zähler auslesen und direktes Counter resetten)
mode=DAPI_CNT_MODE_READ_LATCHED (Auslesen des gespeicherten Zählerstandes)


Return-Wert

Ausgabe des Zählerwertes

Requirements

Die folgenden SW-Feature-Bits müssen vom Modul unterstützt werden:

DAPI_SW_FEATURE_BIT_CFG_DI_CNT

Die Folgenden Bedingungen für die Übergabeparameter müssen eingehalten werden:

maxCh = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_GET_MODULE_CONFIG, DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_DI_COUNTER, 0, 0);
maxCh > ch

Programmierbeispiel

value = DapiDIGetCounter(handle, 0 ,0); // Zähler von DI Chan 0 wird gelesen
value = DapiDIGetCounter(handle, 1 ,0); // Zähler von DI Chan 1 wird gelesen
value = DapiDIGetCounter(handle, 8 ,0); // Zähler von DI Chan 8 wird gelesen
value = DapiDIGetCounter(handle, 0 ,DAPI_CNT_MODE_READ_WITH_RESET); // Zähler von DI Chan 0 wird gelesen UND resettet
value = DapiDIGetCounter(handle, 1, DAPI_CNT_MODE_READ_LATCHED); // Auslesen des gespeicherten Zählerstandes von DI Chan 1

Digitale Ausgabe-Funktionen

DapiDOSet1

Dieser Befehl setzt einen einzelnen Ausgang.

close

DapiDOSet1

Beschreibung

Dieser Befehl setzt einen einzelnen Ausgang.

Definition

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

Parameter

handle=Dies ist das Handle eines geöffneten Moduls
ch=Gibt die Nummer des zu setzenden Ausgangs an (0 .. )
data=Gibt den Datenwert an, der geschrieben wird (0 / 1)


Return-Wert

Keiner

Requirements

Die folgenden SW-Feature-Bits müssen vom Modul unterstützt werden:

DAPI_SW_FEATURE_BIT_CFG_DO

Die Folgenden Bedingungen für die Übergabeparameter müssen eingehalten werden:

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

DapiDOSet8

Dieser Befehl setzt gleichzeitig 8 digitale Ausgänge.

close

DapiDOSet8

Beschreibung

Dieser Befehl setzt gleichzeitig 8 digitale Ausgänge.

Definition

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

Parameter

handle=Dies ist das Handle eines geöffneten Moduls
ch=Gibt die Nummer des Ausgangs an, ab dem geschrieben werden soll (0, 8, 16, 24, 32, ..)
data=Gibt die Datenwerte an, die geschrieben werden


Return-Wert

Keiner

DapiDOSet16

Dieser Befehl setzt gleichzeitig 16 digitale Ausgänge.

close

DapiDOSet16

Beschreibung

Dieser Befehl setzt gleichzeitig 16 digitale Ausgänge.

Definition

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

Parameter

handle=Dies ist das Handle eines geöffneten Moduls
ch=Gibt die Nummer des Ausgangs an, ab dem geschrieben werden soll (0, 16, 32, ..)
data=Gibt die Datenwerte an, die geschrieben werden


Return-Wert

Keiner

DapiDOSet32

Dieser Befehl setzt gleichzeitig 32 digitale Ausgänge.

close

DapiDOSet32

Beschreibung

Dieser Befehl setzt gleichzeitig 32 digitale Ausgänge.

Definition

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

Parameter

handle=Dies ist das Handle eines geöffneten Moduls
ch=Gibt die Nummer des Ausgangs an, ab dem geschrieben werden soll (0, 32, 64, ..)
data=Gibt die Datenwerte an, die geschrieben werden


Return-Wert

Keiner

Programmierbeispiel

// Einen Wert auf die Ausgänge schreiben
data = 0x0000ff00; // Ausgänge 9-16 werden 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();
// ----------------------------------------------------
// Einen Wert auf die Ausgänge schreiben
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();
// ----------------------------------------------------
// Einen Wert auf die Ausgänge schreiben
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();

DapiDOSet64

Dieser Befehl setzt gleichzeitig 64 digitale Ausgänge.

close

DapiDOSet64

Beschreibung

Dieser Befehl setzt gleichzeitig 64 digitale Ausgänge.

Definition

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

Parameter

handle=Dies ist das Handle eines geöffneten Moduls
ch=Gibt die Nummer des Ausgangs an, ab dem geschrieben werden soll (0, 64, ..)
data=Gibt die Datenwerte an, die geschrieben werden


Return-Wert

Keiner

DapiDOClrBit32

Mit diesem Befehl können Ausgänge gezielt auf 0 geschaltet werden, ohne die Zustände der benachbarten Ausgänge zu ändern.

close

DapiDOClrBit32

Beschreibung

Mit diesem Befehl können Ausgänge gezielt auf 0 geschaltet werden, ohne die Zustände der benachbarten Ausgänge zu ändern.

Definition

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

Parameter

handle = Dies ist das Handle eines geöffneten Moduls
ch = Gibt die Nummer des Ausgangs an, ab dem geschrieben werden soll
data = Gibt den Datenwert an, der geschrieben werden soll (bis zu 32 Bit)


Return-Wert

Keiner

Bemerkung

Nur die Bits mit einer Wertigkeit von 1 im data Parameter werden vom Befehl berücksichtigt.

Programmierbeispiel

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

DapiDOSetBit32

Mit diesem Befehl können Ausgänge gezielt auf 1 geschaltet werden, ohne die Zustände der benachbarten Ausgänge zu ändern.

close

DapiDOSetBit32

Beschreibung

Mit diesem Befehl können Ausgänge gezielt auf 1 geschaltet werden, ohne die Zustände der benachbarten Ausgänge zu ändern.

Definition

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

Parameter

handle = Dies ist das Handle eines geöffneten Moduls
ch = Gibt die Nummer des Ausgangs an, ab dem geschrieben werden soll
data = Gibt den Datenwert an, der geschrieben werden soll (bis zu 32 Bit)


Return-Wert

Keiner

Bemerkung

Nur die Bits mit einer Wertigkeit von 1 im data Parameter werden vom Befehl berücksichtigt.

Programmierbeispiel

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

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

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

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

DapiDOReadback32

Dieser Befehl liest die 32 digitalen Ausgänge zurück.

close

DapiDOReadback32

Beschreibung

Dieser Befehl liest die 32 digitalen Ausgänge zurück.

Definition

ULONG DapiDOReadback32(ULONG handle, ULONG ch);

Parameter

handle=Dies ist das Handle eines geöffneten Moduls
ch=Gibt die Nummer des Ausgangs an, ab dem zurückgelesen werden soll (0, 32, 64, ..)


Return-Wert

Zustand von 32 Ausgängen.

DapiDOReadback64

Dieser Befehl liest die 64 digitalen Ausgänge zurück.

close

DapiDOReadback64

Beschreibung

Dieser Befehl liest die 64 digitalen Ausgänge zurück.

Definition

ULONGLONG DapiDOReadback64(ULONG handle, ULONG ch);

Parameter

handle=Dies ist das Handle eines geöffneten Moduls
ch=Gibt die Nummer des Ausgangs an, ab dem zurückgelesen werden soll (0, 64, ..)


Return-Wert

Zustand von 64 Ausgängen.

Spezial-Funktionen

DapiSpecialCommand - DapiSpecialCMDTimeout

Dieser Befehl dient zum Setzen der Timeout-Zeit.

close

DapiSpecialCommand - DapiSpecialCMDTimeout

Beschreibung

Dieser Befehl dient zum Setzen der Timeout-Zeit.

Definition

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

Parameter

handle=Dies ist das Handle eines geöffneten Moduls

Timeout-Zeit setzen
cmd=DAPI_SPECIAL_CMD_TIMEOUT_SET_VALUE_SEC
par1=Sekunden [s]
par2=Millisekunden [100ms] (Wert 6 bedeutet 600ms)

Timeout aktivieren
cmd=DAPI_SPECIAL_CMD_TIMEOUT_ACTIVATE

Timeout deaktivieren
cmd=DAPI_SPECIAL_CMD_TIMEOUT_DEACTIVATE


Programmierbeispiel

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT, DAPI_SPECIAL_TIMEOUT_SET_VALUE_SEC, 3, 7);
//Die Zeit des Timeouts wird auf 3,7sek gesetzt.
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT, DAPI_SPECIAL_TIMEOUT_ACTIVATE, 0, 0);
//Der Timeout wird aktiviert.
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT, DAPI_SPECIAL_TIMEOUT_DEACTIVATE, 0, 0);
//Der Timeout wird deaktiviert.

DapiSpecialCommand - DapiSpecialCMDTimeoutGetStatus

Dieser Befehl dient zum Auslesen des Timeout-Status.

close

DapiSpecialCommand - DapiSpecialCMDTimeoutGetStatus

Beschreibung

Dieser Befehl dient zum Auslesen des Timeout-Status.

Definition

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

Parameter

handle=Dies ist das Handle eines geöffneten Moduls


Return-Wert

Return=0 (Timeout ist deaktivert)
Return=1 (Timeout ist aktiviert)
Return=2 (Timeout hat stattgefunden)

Programmierbeispiel

status = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT, DAPI_SPECIAL_TIMEOUT_GET_STATUS, 0, 0); //Abfrage des Timeout-Status.

Digitale Eingabe-Funktionen

DapiSpecialCommand - Dapi_Special_DI_FF_Filter_Value_Set

Dieser Befehl setzt einen Filter [ms], in welchem Zeitintervall digitale Eingangskanäle abgetastet werden.

close

DapiSpecialCommand - Dapi_Special_DI_FF_Filter_Value_Set

Beschreibung

Dieser Befehl setzt einen Filter [ms], in welchem Zeitintervall digitale Eingangskanäle abgetastet werden.

Definition

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

Parameter

handle=Dies ist das Handle eines geöffneten Moduls
time_ms=Zeitintervall [ms], indem digitale Eingangskanäle abgetastet werden.


Return-Wert

Keiner.

Bemerkung

Dieser Befehl unterstützt nur Impulszeiten zwischen 5ms und 255ms.
Wird keine Zeit gesetzt, ist der Default-Wert 100ms.

Dieser Befehl wird nicht von unseren Modulen mit Ethernet-Schnittstelle unterstützt.

Programmierbeispiel

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_DI, DAPI_SPECIAL_DI_FF_FILTER_VALUE_SET, 5, 0);
// Setzt das Zeitintervall auf 5ms
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_DI,
DAPI_SPECIAL_DI_FF_FILTER_VALUE_SET, 150, 0);
// Setzt das Zeitintervall auf 150ms

DapiSpecialCommand - Dapi_Special_DI_FF_Filter_Value_Get

Dieser Befehl gibt den Filter [ms] zurück, in welchem Zeitintervall digitale Eingangskanäle abgetastet werden.

close

DapiSpecialCommand - Dapi_Special_DI_FF_Filter_Value_Get

Beschreibung

Dieser Befehl gibt den Filter [ms] zurück, in welchem Zeitintervall digitale Eingangskanäle abgetastet werden.

Definition

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

Parameter

handle=Dies ist das Handle eines geöffneten Moduls


Return-Wert

Zeit [ms]

Bemerkung

Dieser Befehl wird nicht von unseren Modulen mit Ethernet-Schnittstelle unterstützt.

Programmierbeispiel

value = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_DI, DAPI_SPECIAL_DI_FF_FILTER_VALUE_GET, 0, 0);
//Gibt das Zeitintervall zum Abtasten der digitalen Eingangskanäle zurück.

Software FIFO-Funktionen

DapiSpecialCMDSoftwareFifo

Dieser Befehl verwaltet die Steuerung des Software-FIFO bei RO-ETH-Modulen.

close

DapiSpecialCMDSoftwareFifo

Beschreibung

Dieser Befehl verwaltet die Steuerung des Software-FIFO bei RO-ETH-Modulen.

Definition

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

Parameter

handle=Dies ist das Handle eines geöffneten Moduls

Software FIFO aktivieren
cmd=DAPI_SPECIAL_SOFTWARE_FIFO_ACTIVATE

Software FIFO deaktivieren
cmd=DAPI_SPECIAL_SOFTWARE_FIFO_DEACTIVATE

Software FIFO Status abfragen
cmd=DAPI_SPECIAL_SOFTWARE_FIFO_GET_STATUS


Return-Wert

cmd=DAPI_SPECIAL_SOFTWARE_FIFO_ACTIVATE
kein return Wert

cmd=DAPI_SPECIAL_SOFTWARE_FIFO_DEACTIVATE
kein return Wert

cmd=DAPI_SPECIAL_SOFTWARE_FIFO_GET_STATUS
return=0 (Software FIFO deaktiviert)
return=1 (Software FIFO aktiviert)

Programmierbeispiel

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

Dieser Befehl liest den Software-FIFO aus. Die ausgelesenen Datensätze werden nach dem Lesen aus dem Software-FIFO des Moduls gelöscht.

close

DapiReadFifo

Beschreibung

Dieser Befehl liest den Software-FIFO aus. Die ausgelesenen Datensätze werden nach dem Lesen aus dem Software-FIFO des Moduls gelöscht.

Definition

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

Parameter

handle = Dies ist das Handle eines geöffneten Moduls
type = Gibt den FIFO-Typ, der gelesen werden soll
buffer = Buffer für die zu empfangenden Datensätze
buffer_length = Länge des Datensatz-Buffers


Return-Wert

Länge der ausgelesenen FIFO-Datenstätze

Aufbau eines FIFO-Datensatz (Beispiel mit 2 aktiven AD Kanälen, AD0 und AD4)

ByteBedeutungWert [hex] 0RO_FIFO_ID_START0xf0 1FIFO-Typ 2Zeitstempel (Bit0..Bit7) 3Zeitstempel (Bit8..Bit15) 4Aktive A/D-Kanäle (Bit0..Bit7)0x11 5Aktive A/D-Kanäle (Bit8..Bit15)0x00 6A/D Wert Kanal 0 (Bit0..Bit7) 7A/D Wert Kanal 0 (Bit8..Bit15) 8A/D Wert Kanal 4 (Bit0..Bit7) 9A/D Wert Kanal 4 (Bit8..Bit15) 10RO_FIFO_ID_END0xf1
FIFO-Datenstatz = 7 Bytes ID + (2 x Anzahl aktiver A/D-Kanäle) Bytes Daten

RO_FIFO_ID_START
Signalisiert den Anfang eines neuen FIFO-Datensatzes. Die RO_FIFO_ID_START hat immer den Wert 0xf0 [hex]

FIFO Typ
Gibt den FIFO Typ an (z.B. RO_FIFO_ID_TYPE_AD16M0 für A/D-FIFO)

Zeitstempel
Gibt den 16 Bit Zeitstempel des aktuellen Datensatzes an. Zeit-Referenz ist hierbei der Zeitpunkt der Aktivierung des FIFO.
Beim Überlauf des Zeitstempels, wird dieser auf 0 zurückgesetzt.

Aktive A/D-Kanäle
Gibt einen 16 Bit Wert für die aktuell aktiven A/D-Kanäle an. Jedes Bit steht für einen Kanal (Bit0 -> AD0, Bit1 -> AD1, .. Bit15 -> AD15).
Ist das Bit gesetzt, ist der entsprechende A/D-Kanal aktiv

RO_FIFO_ID_END
Signalisiert das Ende eines FIFO-Datensatzes. Die RO_FIFO_ID_END hat immer den Wert 0xf1 [hex]

Bemerkung

Dieser Befehl wird nur von unseren Modulen der RO-ETH-Serie unterstützt.
Beachten Sie, dass der Software FIFO zuvor mit den Befehlen "DapiSpecialCMDSoftwareFifo" und "DapiSpecialCMDAD" aktiviert, bzw. initialisiert werden muss.

Programmierbeispiel

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

DapiSpecialCMDAD

Dieser Befehl verwaltet die Steuerung des Software-FIFO eines A/D-Wandlers.

close

DapiSpecialCMDAD

Beschreibung

Dieser Befehl verwaltet die Steuerung des Software-FIFO eines A/D-Wandlers.

Definition

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

Parameter

handle = Dies ist das Handle eines geöffneten Moduls
ch_range = Gibt die Nummer des A/D-Wandler Moduls an (siehe Beispiel bzw. Datei delib.h)

FIFO initialisieren
cmd=DAPI_SPECIAL_AD_FIFO_INIT
par0=nicht definiert

FIFO aktivieren
cmd=DAPI_SPECIAL_AD_FIFO_ACTIVATE
par0=nicht definiert

FIFO deaktivieren
cmd=DAPI_SPECIAL_AD_FIFO_DEACTIVATE
par0=nicht definiert

FIFO Interval setzen
cmd=DAPI_SPECIAL_AD_FIFO_SET_INTERVAL_MS
par0=Intervall [msec]

FIFO für einen A/D-Wandler Kanal setzen
cmd=DAPI_SPECIAL_AD_FIFO_SET_CHANNEL
par0=16 Bit Wert für A/D-Kanäle, die in den FIFO geschrieben werden. Jedes Bit steht für einen Kanal (Bit0 -> AD0, Bit1 -> AD1, .. Bit15 -> AD15).
Ist das Bit gesetzt, ist der entsprechende A/D-Kanal aktiv.

FIFO Status abfragen
cmd=DAPI_SPECIAL_AD_FIFO_GET_STATUS
par0=nicht definiert


Return-Wert

cmd=DAPI_SPECIAL_AD_FIFO_INIT
kein return Wert

cmd=DAPI_SPECIAL_AD_FIFO_ACTIVATE
kein return Wert

cmd=DAPI_SPECIAL_AD_FIFO_DEACTIVATE
kein return Wert

cmd=DAPI_SPECIAL_AD_FIFO_SET_INTERVAL_MS
kein return Wert

cmd=DAPI_SPECIAL_AD_FIFO_SET_CHANNEL
kein return Wert

cmd=DAPI_SPECIAL_AD_FIFO_GET_STATUS
return=aktueller FIFO-Status

Wert [hex]BedeutungErklärung 0x80RO_FIFO_STATUS_MASK_MEASURE_ENABLEDFIFO ist aktiv 0x40RO_FIFO_STATUS_MASK_TEST_DATA 0x20RO_FIFO_STATUS_MASK_OVERFLOWFIFO Buffer ist voll 0x10RO_FIFO_STATUS_MASK_UNDERRUN 0x08RO_FIFO_STATUS_FULL_256_BYTE256 Byte Daten vorhanden 0x04RO_FIFO_STATUS_FULL_64_BYTE64 Byte Daten vorhanden 0x02RO_FIFO_STATUS_FULL_16_BYTE16 Byte Daten vorhanden 0x01RO_FIFO_STATUS_FULL_1_BYTE1 Byte Daten vorhanden

Programmierbeispiel

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);
// initialze 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 100ms fir 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 which should be recorded for AD module 0 (channel 0 to 15)
// 0x1051 [hex] = 0001 0000 0101 0001 [bin]
// the following channels will be 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

Steckverbinder

Schraubenloses Stecksystem

Die Ein- bzw. Ausgangsverbinder sind mit praktischen, schraublosen Steckklemmleisten versehen. Eine Auswurfmechanik erleichtert das Abnehmen der kompletten Anschlussklemme und ermöglicht somit einen schnellen Modultausch ohne zusätzliches Werkzeug.

Anschlussbeispiel an einen DEDITEC Steckverbinder

Schritt 1

Bei allen Produkten der RO- und BS-Serie ist im Lieferumfang ein Werkzeug zur Betätigung der schraublosen Steckverbinder enthalten.

Bild klicken um zu vergrössern

Vergrößerte Ansicht

Bild klicken um zu vergrössern

Vergrößerte Ansicht

Schritt 2

Um die Klemmkontakte für den Leitungsanschluss an den Steckverbindern zu öffnen, wird der Steckstift kräftig von oben, in die seitliche schmale Öffnung gedrückt.

Schritt 3

Wenn man in die Kontaktöffnung schaut, lässt sich erkennen, dass sich die Metallklemmen geöffnet haben. Die Anschlussleitung sollte am Ende 5-7mm abisoliert sein und muss jetzt so tief wie möglich in den geöffneten Kontakt gesteckt werden.

Bild klicken um zu vergrössern

Vergrößerte Ansicht

Bild klicken um zu vergrössern

Vergrößerte Ansicht

Schritt 4

Anschließend wird der Steckstift wieder herausgezogen. Die Klemme ist nun wieder geschlossen.

Schritt 5

Bei korrektem Anschluss, lässt sich die Leitung von Hand jetzt nicht mehr ohne weiteres herausziehen.

Bild klicken um zu vergrössern

Vergrößerte Ansicht

Zubehör

Hutschiene-1m

Hutschiene-1m

Die 1m Hutschiene eignet sich optimal zur schnellen Montage unserer Steuer/Regeltechnik-Module.

12V Hutschienen-Relais

12V Hutschienen-Relais

Dieses Industrie-Relais für Hutschienenmontage wird mit einer Eingangsspannung von 12V DC angesteuert. Spannungen von bis 250V AC/DC können hierbei geschaltet werden.

230V Hutschienen-Relais

230V Hutschienen-Relais

Sie möchten überprüfen ob 230V AC auf ihrer Schaltung anliegen?
Angesteuert werden können diese Relais beispielsweise durch unsere Opto-In-Eingänge. Als Steuerspannung muss hierbei 230V AC/220V DC benutzt werden.

24V Hutschienen-Relais

24V Hutschienen-Relais

Reichen die Schaltleistungen unserer Module nicht aus?
Angesteuert werden können diese Relais beispielsweise durch unsere Relais oder MOS-Ausgänge. Als Steuerspannung muss hierbei 24V DC benutzt werden.

230V Hutschienen-Solid-State-Relais für induktive Lasten

230V Hutschienen-Solid-State-Relais für induktive Lasten

Mit diesem Solid-State-Relais erweitern wir die maximale Schaltspannung unserer Digitalen Ausgabemodule auf 230V AC.
Angesteuert werden können diese Relais beispielsweise durch unsere Relais oder MOS-Ausgänge. Als Steuerspannung kann hierbei 3.5 ... 32V DC benutzt werden. Mit diesem Solid-State-Relais können induktive Lasten geschaltet werden.

230V Hutschienen-Solid-State-Relais für ohmsche Lasten

230V Hutschienen-Solid-State-Relais für ohmsche Lasten

Mit diesem Solid-State-Relais erweitern wir die maximale Schaltpannung unserer Digitalen Ausgabemodule auf 230V AC.
Angesteuert werden können diese Relais beispielsweise durch unsere Relais oder MOS-Ausgänge. Als Steuerspannung kann hierbei 3.5 ... 32V DC benutzt werden. Mit diesem Solid-State-Relais können ohmsche Lasten geschaltet werden.

8-fach Relais-Leistungsmodul (UM-Schalter, 40V/10A) mit Ansteuermöglichkeit von Relais/Optokopplern

8-fach Relais-Leistungsmodul (UM-Schalter, 40V/10A) mit Ansteuermöglichkeit von Relais/Optokopplern

Das MOD-REL8_10A ist ein Erweiterungsmodul mit 8 * Relais 10A. Angesteuert werden kann das MOD-REL8_10A entweder durch Optokoppler-Ausgänge (z.B. SPS) oder Relais-Ausgängen, die selbst nicht so viel schalten können.

Netzteil 24V/2A für Hutschienenmontage

Netzteil 24V/2A für Hutschienenmontage

Das Hutschienen-Netzteil bietet Anwendern eine sichere Arbeitsumgebung und ist eine ideale Spannungsversorgung für unsere Steuer/Regeltechnik-Module. Es besitzt einen Wirkungsgrad von bis zu 80% und Internationale Sicherheitszulassungen Dank der Isolationsklasse 2 als auch der Sicherheit die das Hutschienen-Netzteil bietet.

16 poliger Steckverbinder mit Auswerfmechanik

16 poliger Steckverbinder mit Auswerfmechanik

Unsere Steckverbinder bieten einen einfachen und sicheren Anschluss an unsere Module. Durch die integrierte Schraubverriegelung ist das nachträgliche Austauschen der angeschlossenen Module möglich.

APP

I/O-Control APP für Android™

Get it on Google Play
Von unterwegs aus die digitalen und analogen I/Os unserer Ethernetmodule steuern. Durch die DEDITEC I/O-Control Android App wird jedes netzwerkfähige Android Gerät zur Fernsteuerung für DEDITEC Produkte mit Ethernet-Schnittstelle

Features:

  • Separates Speichern der Netzwerkeinstellungen für private und öffentliche Netze
  • Bessere Übersichtlichkeit durch konfigurierbare I/O-Namen
  • Konfigurierbarer Refresh aller I/Os

Folgende I/Os werden unterstützt:

  • bis zu 128 analoge Eingänge (0..10V, 0..5V, +/- 10V und +/- 5V)
  • bis zu 64 analoge Ausgänge (0..10V, 0..5V, +/- 10V und +/- 5V)
  • bis zu 128 digitale Ein- und Ausgänge

Bildergalerie:

Bild klicken um zu vergrössern

Vergrößerte Ansicht

Netzwerkeinstellungen

In den Netzwerkeinstellungen kann wahlweise eine Konfiguration für private (WLAN) oder öffentliche (Internet) Netze erstellt und gespeichert werden.

Modulkonfiguration

Bei der Modulkonfiguration sehen Sie die Anzahl der angeschlossenen I/O-Module. Zudem können Sie hier auswählen, welche I/Os gesteuert werden sollen.

Bild klicken um zu vergrössern

Vergrößerte Ansicht

Bild klicken um zu vergrössern

Vergrößerte Ansicht

Digitale Eingänge

Die digitalen Eingänge werden in einem einstellbaren Intervall abgefragt.

Digitale Ausgänge

Im Bereich der digitalen Ausgänge können die Kanäle einzeln ein- bzw. ausgeschaltet werden. Zudem besteht die Möglichkeit alle Kanäle ein- bzw- auszuschalten.

Bild klicken um zu vergrössern

Vergrößerte Ansicht

Bild klicken um zu vergrössern

Vergrößerte Ansicht

Analoge Eingänge

Bei den analogen Eingängen können Sie aus den Messbereichen 0..10V, 0..5V, +/- 10V oder +/- 5V wählen. Das Abfragen der A/D-Kanäle geschiet automatisch in einem einstellbaren Intervall.

Analoge Ausgänge

Hier können Sie analoge Ausgänge im Messbereich 0..10V, 0..5V, +/- 10V oder +/- 5V setzen.

Bild klicken um zu vergrössern

Vergrößerte Ansicht

Bild klicken um zu vergrössern

Vergrößerte Ansicht

Einstellungen

Dieses Bild zeigt die Einstellungen für analoge Ausgänge. Hier kann jedem Kanal ein Name gegeben werden. Zudem kann hier festgelegt werden, ob und in welchem Intervall die analogen Ausgänge zurückgelesen werden. Diese Einstellungen sind für alle I/Os verfügbar.

WEB-Oberfläche

Weboberfläche - Interface

Das DEDITEC BS-ETH-O32-M32 verfügt über eine Weboberfläche, die es Ihnen erlaubt, Einstellungen bequem über Ihren Webbrowser vorzunehmen und bietet Ihnen ausserdem direkten Zugriff auf die I/Os.

Die Weboberfläche bietet Ihnen direkten Zugriff auf die I/Os des Produktes. Somit können Sie beispielsweise mit einem Smartphone, Tablet oder auch einem PC über einen Browser auf das Produkt zugreifen.

Unterstützt werden die folgenden I/O Einheiten der Starter-Serie, BS-Serie und RO-Serie:

  • Digitale Eingänge
  • Digitale Eingänge (Zählerfunktion)
  • Digitale Ausgänge
  • Analoge Eingänge (Spannung & Strom)
  • Analoge Ausgänge (Spannung & Strom)
  • PT100 Temperaturerfassung
  • Schrittmotorensteuerung

Mit einem Benutzersystem sowie optionalem Verschlüsselungssystem können Sie das BS-ETH-O32-M32 gegen Fremdzugriffe schützen.

Bild klicken um zu vergrössern

Vergrößerte Ansicht

General

Startseite der Weboberfläche. Über die Navigation auf der linken Seite erhalten Sie Zugriff auf diverse Einstellungsmöglichkeiten.

Network configuration

Alle Netzwerkeinstellungen können direkt über die Weboberfläche durchgeführt werden.

Bild klicken um zu vergrössern

Vergrößerte Ansicht

Bild klicken um zu vergrössern

Vergrößerte Ansicht

Usermanager

Hier kann der Benutzername und das Passwort für den Zugriff auf die Weboberfläche bestimmt werden. Ist der Benutzter inaktiv, wird dieser automatisch nach Ablauf der Session Time ausgeloggt.

Status / Reboot

Version der installierten Firmware. Funktionen zum Neustarten und Zurücksetzen der Einstellungen.

Bild klicken um zu vergrössern

Vergrößerte Ansicht

Bild klicken um zu vergrössern

Vergrößerte Ansicht

Security

Neben einem Benutzer/Passwort System für die Weboberfläche bieten wir Ihnen auch die Möglichkeit die gesamte Netzwerkkommunikation zu verschlüsseln. Auch der Zugriff auf die I/Os kann gesperrt werden.


Unterstütze I/Os

Folgend zeigen wir Ihnen die unterstützten I/Os die Sie über die Weboberfläche bedienen können.

Digitale Ein-/Ausgänge

Die digitalen I/Os werden von unserer Starter-Serie, der BS-Serie sowie unserer RO-Serie unterstützt.
Bild klicken um zu vergrössern

Vergrößerte Ansicht

Digital Inputs

Das Bild zeigt die Übersicht der digitalen Eingänge. Über das Drop-Down Menü kann zwischen mehreren Eingängen gewechselt werden. Die Spalte 'State' zeigt, ob ein Signal am Eingang anliegt.

Digital Inputs Counter

Unsere digitalen Eingänge verfügen über eine Zählfunktion. Über die Weboberfläche kann der Zählerstand gelesen und zurückgesetzt werden.

Bild klicken um zu vergrössern

Vergrößerte Ansicht

Bild klicken um zu vergrössern

Vergrößerte Ansicht

Digital Outputs

Die digitalen Ausgänge können über einen On-/Off-Button geschaltet werden. Der aktuelle Zustand der Ausgänge kann über die Spalte 'Readback' zurückgelesen werden.



Analoge Ein-/Ausgänge

Die analogen I/Os werden von unserer RO-Serie unterstützt.

Analog Inputs

Strom sowie Spannungen können auch über die Weboberfläche ausgelesen werden. Über das A/D Mode Drop-Down Menü kann der gewünschte Betriebsmodus eingestellt werden.

Bild klicken um zu vergrössern

Vergrößerte Ansicht

Bild klicken um zu vergrössern

Vergrößerte Ansicht

Analog Outputs

Die Ausgabe von anlogen Signalen kann auch über die Weboberfläche erfolgen. Der gewünschte D/A Modus kann wie bei den analogen Eingängen über das Drop-Down Menü eingestellt werden. Der gewünschte Wert kann über den 'SET' Button auf die Ausgänge geschrieben werden. Die Spalte 'Readback' zeigt die aktuelle Spannung-/Stromausgabe des D/A Wandlers.



Temperaturerfassung (PT100)

Die Temperaturerfassung wird von unserer RO-Serie unterstützt.

PT100

Die aktuelle Temperatur kann abgelesen werden. Ist kein Sensor am Kanal angeschlossen, wird dies mit 'disconnected' signalisiert.

Bild klicken um zu vergrössern

Vergrößerte Ansicht



Schrittmotorsteuerung

Die Schrittmotorsteuerung wird von unserer RO-Serie unterstützt.
Bild klicken um zu vergrössern

Vergrößerte Ansicht

Stepper-Motor Control

Über die Kontrollelemente kann die Position sowie Geschwindigkeit des Stepper-Motors gesetzt werden. Das Statusfenster zeigt die aktuelle Position, Temperatur sowie Spannungsversorgung.

Downloads

Manuals

Handbuch ETH Übertragungsprotokoll

Handbuch ETH Übertragungsprotokoll

Beschreibung der Sende- und Empfangsrahmen

  • Beschreibung der Registerzugriffe
  • Aufbau des TCP/IP Protokolls
  • Aufbau des Sende-/Empfangsstrings


Handbuch BS-Serie

Handbuch BS-Serie

Hardware- und Software-Beschreibung

  • Beschreibung der Steuer-/Regelungstechnik-Module
  • Konfiguration der unterschiedlichen Modul-Schnittstellen
  • Softwareinstallation der DELIB-Treiber-Bibliothek


Handbuch Protokolle & Registerbelegung

Handbuch Protokolle & Registerbelegung

Übertragungsprotokolle und Registerbelegung


Beschreibt den Aufbau unseres Ethernet-/Seriell- und CAN-Protokolls.
Beinhaltet auch eine Übersicht der Register für den Zugriff auf Ein-/Ausgänge und Zusatzfunktionen eines Produktes.

Treiber / Programme

DELIB Treiberbibliothek für Linux (32/64-Bit)

DELIB Treiberbibliothek für Linux (32/64-Bit)

Für 32/64-Bit Linux-Distributionen ab Kernel 2.6.x


DELIB Treiberbibliothek für Linux-Distributionen (32/64-Bit) ab Kernel 2.6.x

Dieses Treiberpaket beinhaltet folgende Komponenten

  • DELIB USB Treiber
  • DELIB Ethernet Treiber
  • DELIB CLI

DELIB USB Treiber


Unterstützung für folgende Produkte:

  • NET-Serie (über USB Schnittstelle)
  • RO-USB-Serie
  • BS-USB-Serie
  • USB-Mini-Sticks
  • USB-Watchdog
  • USB-OPTION-8 / USB-RELAIS-8
  • USB-TTL-32 / USB-TTL-64

Hinweis:
Mit der Standard Ausführung des USB Treibers können mehrere USB Produkte mit unterschiedlichen Modul-IDs (z.B. ein RO-USB und ein USB-OPTOIN-8) angesprochen werden. Hierbei ist keine weitere Treiberinstallation erforderlich.

Wenn mehrere USB Produkte mit gleicher Modul-ID (z.B. ein USB-OPTOIN-8 und ein USB-RELAIS-8) angesprochen werden sollen, muss zusätzlich der Linux FTDI-Treiber installiert sein. Den FTDI-Treiber finden Sie unter http://www.ftdichip.com.

DELIB Ethernet Treiber


Unterstützung für folgende Produkte:

  • NET-Serie (über Ethernet Schnittstelle)
  • RO-ETH-Serie
  • RO-ETH/LC-Serie
  • BS-ETH-Serie
  • ETH-OPTION-8 / ETH-RELAIS-8
  • ETH-TTL-64

DELIB CLI


Mit dem DELIB CLI (Command Line Interface) für Linux können alle Befehle für digitale und analoge I/Os direkt über die Kommando-Zeile gesetzt werden


Manual der DELIB Treiberbibliothek

Manual der DELIB Treiberbibliothek

Dokumentation aller Befehle für die Treiberbibliothek

  • Windows 10, 8, Vista, 7, XP, 2000 und Linux
  • Modul open/close Funktionen
  • Digitale Eingänge: Lesen von 1 / 8 / 16 / 32 / 64 bit
  • Digitale Ausgänge: Schreiben von 1 / 8 / 16 / 32 / 64 bit
  • A/D Lesen: read, read_volt, read_mA, set A/D mode
  • D/A schreiben: write, write_volt, write_mA, set D/A mode


Download

Windows

DELIB Setup für Windows (32/64-Bit)

DELIB Setup für Windows (32/64-Bit)

Für Windows 10, Windows 7, Windows 8, Vista, XP und 2000


Mit dem DELIB Setup erhalten Sie einen benutzerfreundlichen Setup-Assistenten. Hierbei wird neben der DELIB-Treiberbibliothek bei Bedarf auch die DELIB Sample Sources installiert.

Die folgenden Betriebssysteme sind kompatibel:

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


Firmware

Hardware-Updates (Firmware)

Hardware-Updates (Firmware)

Flash Files für den DT-Flasher


Die Flash Files können auch direkt im DT-Flasher heruntergeladen werden.

Dieses Paket enthält Firmware Dateien für die folgenden Produkte:

STARTER-Serie:
  • USB-MINI-Sticks
  • USB-8-er Opto/Relais
  • Ethernet 8-er Opto/Relais
  • USB-TTL I/O
  • Ethernet-TTL I/O

BS-Serie:
  • BS-CAN Module
  • BS-ETH Module
  • BS-USB Module
  • BS-SER Module

RO-Serie Interfaces:
  • RO-USB
  • RO-SER
  • RO-ETH
  • RO-ETH/LC
  • RO-CAN

RO-Serie I/Os:
  • AD / DA Module
  • CNT8 / CNT-IGR
  • O8-R8 Zeitmodul
  • PT100
  • Stepper2

Entwicklungszubehör
  • USB Controller 8
  • USB Watchdog Stick


Beispielsoftware

DELIB-Samples Installationspaket (ca. 10 MB)

DELIB-Samples Installationspaket (ca. 10 MB)

Beispielprogramme für verschiedene Programmiersprachen (Im DELIB Setup enthalten)

  • C (Microsoft Visual C++ 6.0, Borland C)
  • C++ (Microsoft Visual C++ 6.0)
  • C# (Microsoft Visual C# 2008 bis 2015)
  • Delphi (Borland Delphi 7)
  • VB (Microsoft Visual Basic 6.0)
  • VB.NET (Microsoft Visual Basic 2008 bis 2015)
  • Java (Java Native Interface)
  • Java.dll (Ethernet-Protokoll für Ethernet-Produkte)


DELIB VI's für LabVIEW® 2011

DELIB VI's für LabVIEW® 2011

VI's zur Ansteuerung unserer Produkte in LabVIEW®

LabVIEW® Beispielprogramm für analoge und digitale Ein-/Ausgänge

LabVIEW® Beispielprogramm für analoge und digitale Ein-/Ausgänge

Beispielprogramm für analoge und digitale Ein-/Ausgänge

Online Manuals (Direkter Link: http://manuals.deditec.de)

Online Manuals

Handbuch ETH Übertragungsprotokoll

Handbuch ETH Übertragungsprotokoll

Beschreibung der Sende- und Empfangsrahmen

  • Beschreibung der Registerzugriffe
  • Aufbau des TCP/IP Protokolls
  • Aufbau des Sende-/Empfangsstrings


Handbuch BS-Serie

Handbuch BS-Serie

Hardware- und Software-Beschreibung

  • Beschreibung der Steuer-/Regelungstechnik-Module
  • Konfiguration der unterschiedlichen Modul-Schnittstellen
  • Softwareinstallation der DELIB-Treiber-Bibliothek


Handbuch Protokolle & Registerbelegung

Handbuch Protokolle & Registerbelegung

Übertragungsprotokolle und Registerbelegung


Beschreibt den Aufbau unseres Ethernet-/Seriell- und CAN-Protokolls.
Beinhaltet auch eine Übersicht der Register für den Zugriff auf Ein-/Ausgänge und Zusatzfunktionen eines Produktes.




Beschreibung
Software
Technische Daten
Konfiguration
Lieferumfang
Blockschaltbilder
Anschlussbeispiele
DELIB-API Befehle
Steckverbinder
Zubehör
APP
WEB-Oberfläche
Downloads
Online Manuals

TOP 5 DOWNLOADS

  • DELIB Treiberbibliothek
  • DELIB Dokumentation
  • DELIB Sample Installer
  • Hardware-Updates (Firmware)

NEU IM SORTIMENT

  • NET-Serie - Profilösung für Steuer- & Regelungstechnik
  • Ethernet-TTL I/O und
    Ethernet-Opto/Relais Module

DEDITEC Produkte

  • Embedded Systeme
  • Logikanalysatoren
  • Steuer- und Regelungstechnik
  • Entwicklungszubehör

Allgemeines

  • Presse
  • Jobs
  • Newsletter
  • Impressum
  • Datenschutz
  • Sitemap

Sitemap | Impressum © DEDITEC GmbH, 2019