8 * Optokoppler-Eingänge über den USB-Bus abfragen

0 Kundenbewertungen

 124,95

Verfügbarkeit: Auf Lager SKU: USB-OPTOIN-8 Kategorie:

Das SB-Optoin-8 ist ein kompaktes USB 2.0 Modul mit 8 Optokoppler Eingängen zur digitalen Erfassung von Spannungen im Bereich von 5V bis 30V. Eine Reihe an Status LEDs visualisieren u.a. die Schaltzustände der Optokoppler. Das Kunststoffgehäuse mit Hutschienenaufnahme erleichtert die Montage in Verteilerschränken. Die Anschlussverdrahtung erfolgt über zwei 8 polige steckbare  Schraubklemmen.

  • 8 Optokoppler-Eingänge (5V-30V AC / DC)
  • Galvanische Trennung der Eingänge über Optokoppler
  • 16 Bit Zähler je Kanal (bis 100Hz)
  • Filter für Zähler / Flip-flops einstellbar von 5ms – 255ms

Digitale Eingänge

Mit unseren Optokoppler Eingängen lassen sich digitale Signalzustände innerhalb eines Spannungsbereiches von 5V bis 30V AC oder DC erfassen. Ein- und Ausgangsstromkreis sind bis zu 2,5kV galvanisch voneinander getrennt.

 

Zähler

Jeder Eingang verfügt über einen 16 Bit-Zähler, mit dem bis zu 65535 Impulse gezählt werden können. Beim Überschreiten des maximalen Zählerstandes beginnt der Zählvorgang wieder bei null. Mittels Software-Befehl kann der aktuelle Stand aller Eingangszähler gleichzeitig in einen separaten Speicherbereich geschrieben werden.

 

Erfassen von Zustandsänderungen

Zustandsänderungen die zwischen den Auslesezyklen stattfinden, werden durch interne Flip-Flops sicher erfasst und können separat per Software ausgelesen werden. Zusätzlich wird solch ein Ereignis durch eine Status LED signalisiert. Das Zurücksetzen erfolgt automatisch nach dem Auslesen der Flip-Flops.


LEDs

Jeder digitale Ein- und Ausgang verfügt über eine separate LED, die bei aktivem Signalzustand aufleuchtet. Desweiteren lassen sich u.a. der Zustand der Betriebsspannung, die Kommunikation mit dem Interface, Fehlerereignisse oder das Auftreten eines Timeouts anzeigen.


Steckverbinder

Als Steckverbinder kommen steckbare Schraubklemmen zum Einsatz. Es lassen sich Leiterquerschnitte bis 3,3mm² anschließen. Zusätzlichen Halt bieten die beiden Flansch Verschraubungen.


Software und Ansteuerung für Programmierer

Durch unsere mitgelieferte DELIB Treiberbibliothek ist ein einfaches Ansprechen des Produkts über unsere API möglich.

 

Wir bieten Support für folgende Programmiersprachen:

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

Wir bieten Support für folgende Betriebssysteme:

  • Windows 11/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

Entsprechende Programmierbeispiele finden Sie bei den Produkten im Bereich „Software“ oder sind als Lieferumfang auf der Treiber CD enthalten.


Allgemein

Versorgungsspannung +5V (USB-Bus)
Interface USB 2.0 / USB 1.1
Zugriffsgeschwindigkeit Durchschnittliche Zugriffszeit vom PC auf das Modul: 0,4 ms
(Berechnet mit 1000 Zugriffen auf das Modul über die DELIB Treiberbibliothek mit dem Befehl DapiDoSet32)
LEDs • Je eine LED pro Eingangskanal
• USB Aktivität
Steckverbinder • Typ: Würth Elektronik / 691345510008
• Steckbar (fehlsteckgeschützt)
• Anschluss für alle Leiterarten von 0,2mm² bis 3,3mm²
• Schraubflansch
Betriebsstemperatur +10°C .. +50 °C
Abmessungen 67,5 mm x 77 mm x 55 mm (H x B x T)

Digitale Eingänge

Optokoppler Eingänge • 15V bis 30V DC/AC Signalspannung (optional 5V – 15V DC/AC)
• Galvanische Trennung zwischen Ein- und Ausgangsstromkreis : bis 2,5kV AC für 1 Minute
• Maximaler Eingangsstrom: 14mA
Eingangszähler • 16 Bit Zähler pro Kanal
• Maximal mögliche Zählvorgänge: 65535 / Kanal
• Nach Speicherüberlauf Reset auf Null
• Interne Zähllogik bis 100Hz
• Programmierbarer Filter für Eingangskanäle (Flip-Flop und Counter):
• Mindest low bzw. high Impulsdauer: 5ms…255ms
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

Zusätzliche Informationen

Gewicht 0,102 kg
Größe 10000 × 10000 × 10000 cm

 

 

 

Allgemeine Informationen zum ICT-Tool

Um Ihnen die Inbetriebnahme unserer Produkte so leicht und überschaubar wie möglich zu gestalten, haben wir das neue ICT-Tool entwickelt.
Dieses Tool vereint alle wichtigen Funktionen unserer alten Programme, wie zum Beispiel die des Configuration Utilitys, Modul Demo und des DT-Flasher in einem.
Mit dem ICT-Tool können Sie unsere Produkte jetzt ganz einfach Konfigurieren, Testen, Diagnostizieren, Flashen und Debuggen.
In den folgenden Kapitel, würden wir Ihnen unsere neue All-In-One-Software gerne genauer vorstellen.

Modulauswahl

Hier können Sie Ihre Module mit einem Klick auf das „+“ Symbol ins ICT-Tool einbinden, um diese anschließend konfigurieren oder testen zu können.


Startbildschirm

Hier finden Sie einige wichtige Information zu Ihrem ausgewählten Modul.
Zudem können Sie sich hier das Handbuch des Modules als PDF oder HTML-Version anzeigen lassen.
Unter „Show module IDs“ können Sie alle verfügbaren Module IDs aufrufen. Diese ID wird benötigt, um unsere Produkte in Ihre Software-Projekte einzubinden.


ICT Treeview

Im Treeview auf der linken Seite des Programmfensters, sehen Sie die jeweiligen Formen, die von Ihrem Modul unterstützt werden.
Mit einem Klick können Sie sich diese Form dann im rechten Teil des Programmes anzeigen lassen und mögliche Konfigurationen oder Tests durchführen.

Konfiguration

Konfiguration von USB-Modulen

Produkte mit USB-Schnittstelle werden selbstständig von der DELIB Treiberbibliothek erkannt. Eine Konfiguration muss nur vorgenommen werden, falls mehrere identische USB-Produkte am selben System eingesetzt werden sollen.

 


Mehrere identische USB-Module an einem System

Jedes unserer USB Produkte hat im Auslieferungszustand die Modul-Nr „0“. Beim Einsatz von mehr als einem USB Modul an einem PC / System, muss zunächst jedem weiteren Modul eine neue Modul Nr. zugewiesen werden. Diese Zuweisung geschieht mit Hilfe unseres DT-ICT-Tool. Nur so kann softwareseitig eine eindeutige Zuordnung stattfinden. Die Modul-Nr wird fest im Produkt gespeichert. Es können bis zu 255 identische Module an einem System verwendet werden.


Nähere Details zur Ansteuerung sowie einige Programmierbeispiele, finden Sie im Bereich Programmierung.

Programmieren von Modulen über die DELIB-Treiberbibliothek unter Windows

Die umfangreiche und dennoch sehr einfach zu bedienende DELIB-Treiberbibliothek ist für nahezu jede Programmiersprachen geeignet. Ein Installationspaket mit umfangreichen Beispielen finden Sie auf unserer CD oder im Download Bereich.

Downloads

 

Ansteuerung über die Windows Treiberbibliothek DELIB

Die DELIB-Treiberbibliothek ermöglicht ein einheitliches Ansprechen aller DEDITEC Steuer- & Regelungstechnik Produkte. Hierzu stellen wir Programmierern für die jeweiligen Produktgruppen entsprechende Funktionen zur Verfügung, die ein einheitliches aber auch sehr einfaches Ansprechen der Produkte ermöglichen.

 

Hier finden Sie einen Überblick über die DELIB und Ihre Zusatzprogramme:

DELIB + Tools

 

Eine Auflistung aller DELIB Befehle befindet sich hier:

Überblick DELIB API

 


DELIB Treiberbibliothek ETH

Wir bieten auch eine reine Ethernet Version der DELIB Treiberbibliothek an. Nicht enthalten sind alle anderen Treiber, wie USB/SER.
Dies hat den Vorteil, dass keine Installation der Treiberbibliothek oder Konfiguration des Moduls notwendig ist.
Hierdurch haben Projektkunden den Vorteil, dass die Ethernet Treiberbibliothek in das eigene Setup integriert werden kann, wodurch das DELIB Setup nicht ausgeführt werden muss.

Sämtliche Produkte mit Ethernet Schnittstelle werden von dieser Treiberbibliothek unterstützt und lassen sich über die IP-Adresse ansprechen.

 

Hier finden Sie den Download:

DELIB ETH

Die DELIB ermöglicht ein simples Ansprechen von DEDITEC-Modulen

 

Das folgende Beispiel zeigt, wie mit einfachen Mitteln innerhalb kürzester Zeit auf die Eingänge unserer Module zugegriffen werden kann.

 

Öffnen des gewünschten Moduls

handle = DapiOpenModule(RO_ETH,0); // Open the module

 

Lesen von 16 digitalen Eingängen

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

 

Geöffnetes Modul schließen

DapiCloseModule(handle); // Close the module

 

Die Funktion „DapiOpenModule“ dient zum Öffnen eines Produkts. Welches Produkt 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_USB1“ angegeben werden. So wird der Treiberbibliothek mitgeteilt, dass ein RO-Modul mit USB Bus 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 Modul-Nr kann mit dem DT-ICT-Tool geändert werden.


Beispiel für das Ansprechen eines DEDITEC-Moduls

DT-ICT-Tool

Im Lieferumfang enthalten ist das DT-ICT-Tool. Dieses Programm bietet die Möglichkeit alle Ein-/Ausgänge auf einfache Weise anzusprechen und somit auch zu testen.

In diesen Beispiel ist ein BS-WEU angeschlossen. Das angeschlossene BS-WEU verfügt über digitale Ausgänge, diese lassen sich ein- und ausschalten.

 


Programmierung von USB-Modulen

Beispiel für das Öffnen mehrerer Module an einem PC:

 

Öffnen des Moduls mit der Nr „1“

handle1 = DapiOpenModule(RO_USB1,1); // USB-Modul mit Nr=1 öffnen

Öffnen des Moduls mit der Nr „4“

handle2 = DapiOpenModule(RO_USB1,4); // USB-Modul mit Nr=4 öffnen

Verwaltungsfunktionen

DapiOpenModule
Diese Funktion öffnet ein bestimmtes Modul.

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.

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().

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.

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.

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.

DapiClearLastError

Beschreibung

Diese Funktion löscht den letzten mit DapiGetLastError() registrierten Fehler.

 

Definition

void DapiGetLastError(void);

 

Parameter

Keine

 

Return Wert

Keine

 

Beispiel-Programm

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.

DapiClearLastErrorByHandle

 

Beschreibung

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

 

Definition

void DapiClearLastErrorByHandle(ULONG handle);

 

Parameter

handle=Dies ist das Handle eines geöffneten Moduls.

 

Return Wert

Keine

 

Beispiel-Programm

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.

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)

DapiOpenModuleEx
Diese Funktion öffnet gezielt ein Modul mit Ethernet-Schnittstelle. Dabei können die Parameter IP-Adresse, Portnummer und die Dauer des Timeouts bestimmt werden. Das Öffnen des Moduls geschieht dabei unabhängig von den im DELIB Configuration Utility getroffenen Einstellungen.

DapiOpenModuleEx

 

Beschreibung

Diese Funktion öffnet gezielt ein Modul mit Ethernet-Schnittstelle. Dabei können die Parameter IP-Adresse, Portnummer und die Dauer des Timeouts bestimmt werden.
Das Öffnen des Moduls geschieht dabei unabhängig von den im DELIB Configuration Utility getroffenen Einstellungen.

 

Definition

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

 

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
exbuffer = Buffer für IP-Adresse, Portnummer und Dauer des Timeouts

 

Return-Wert

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

 

Bemerkung

Der von dieser Funktion zurückgegebene Handle wird zur Identifikation des Moduls für alle anderen Funktionen benötigt.
Dieser Befehl wird von allen Modulen mit Ethernet-Schnittstelle unterstützt.

 

Programmierbeispiel

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

Digitale Eingabe-Funktionen

DapiDIGet1
Dieser Befehl liest einen einzelnen digitalen Eingang

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)

 

Anforderungen

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

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

 

Anforderungen

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

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

 

Anforderungen

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

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

 

Anforderungen

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

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

 

Anforderungen

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)

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

 

Anforderungen

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

Digitale Eingabe-Counter

DapiDIGetCounter
Dieser Befehl liest den Eingangszähler eines digitalen Eingangs.

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

DapiSpecialCommand - DapiSpecialCounterLatchAll
Dieser Befehl speichert die Zählerstände aller Eingangszähler gleichzeitig in ein Zwischenspeicher (Latch). So können anschließend alle Zählerstände des Latches nacheinander ausgelesen werden. Besonderheit hierbei ist, dass ein gleichzeitiges "Einfrieren" der Zählerstände möglich ist und die Eingefrorenen Stände (Latch) dann einzeln nacheinander ausgelesen werden können.

DapiSpecialCommand – DapiSpecialCounterLatchAll

 

Beschreibung

Dieser Befehl speichert die Zählerstände aller Eingangszähler gleichzeitig in ein Zwischenspeicher (Latch).
So können anschließend alle Zählerstände des Latches nacheinander ausgelesen werden.
Besonderheit hierbei ist, dass ein gleichzeitiges „Einfrieren“ der Zählerstände möglich ist und die Eingefrorenen Stände (Latch) dann einzeln nacheinander ausgelesen werden können.

 

Definition

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

 

Parameter

 

Bemerkung

Dieser Befehl wird nur von unserem O8-R8 Zeitmodulen unterstützt!

 

Programmierbeispiel

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

DapiSpecialCommand - DapiSpecialCounterLatchAllWithReset
Dieser Befehl speichert die Zählerstände aller Eingangszähler gleichzeitig in ein Zwischenspeicher (Latch). Zusätzlich werden die Zählerstände der Eingangszähler im Anschluß resettet.

DapiSpecialCommand – DapiSpecialCounterLatchAllWithReset

 

Beschreibung

Dieser Befehl speichert die Zählerstände aller Eingangszähler gleichzeitig in ein Zwischenspeicher (Latch). Zusätzlich werden die Zählerstände der Eingangszähler im Anschluß resettet.

 

Definition

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

 

Parameter

 

Bemerkung

Dieser Befehl wird nur von unserem O8-R8 Zeitmodulen unterstützt!

 

Programmierbeispiel

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

CNT48-Funktionen

DapiCnt48ModeSet
Dieser Befehl setzt einen Zählmodus (optional auch Submodus) und Eingangsfilter für einen bestimmten Eingangszählerkanal.

DapiCnt48ModeSet

 

Beschreibung

Dieser Befehl setzt einen Zählmodus (optional auch Submodus) und Eingangsfilter für einen bestimmten Eingangszählerkanal.

 

Definition

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

 

Parameter

handle=Dies ist das Handle eines geöffneten Moduls
ch=Nummer des Eingangszählerkanals, dessen Modus gesetzt werden soll (0, 1, 2, 3, .. )
mode=Gibt den Modus an

 

Mögliche Werte für mode

mode=DAPI_CNT48_MODE_COUNT_RISING_EDGE | DAPI_CNT48_SUBMODE_NO_RESET
In diesem Modus wird bei steigender Flanke gezählt.

 

mode=DAPI_CNT48_MODE_COUNT_RISING_EDGE | DAPI_CNT48_SUBMODE_RESET_WITH_READ
In diesem Modus wird bei steigender Flanke gezählt. Zusätzlich wird bei jedem Lesevorgang der Zähler resettet.

 

mode=DAPI_CNT48_MODE_COUNT_RISING_EDGE | DAPI_CNT48_SUBMODE_RESET_ON_CH_7
In diesem Modus wird bei steigender Flanke gezählt. Zusätzlich kann der Zähler über ein externes Signal (letzer Kanal des Moduls = 1) resettet werden.

 

mode=DAPI_CNT48_MODE_COUNT_RISING_EDGE | DAPI_CNT48_SUBMODE_LATCH_COMMON
Mit dem Befehl „DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_CNT48, DAPI_SPECIAL_CNT48_LATCH_GROUP8, 0, 0)“ werden alle 8 Zählerstände der Eingangszähler gleichzeitig in einen Zwischenspeicher (Latch) geschrieben. Mit diesem Modus kann dann der gelatchte Zählerstand ausgelesen werden.

 

mode=DAPI_CNT48_MODE_T
Mit diesem Modus wird die Periodendauer T gemessen. Als Basis hierbei dient ein 100 MHz Zähler.

 

mode=DAPI_CNT48_MODE_FREQUENCY
Bei diesem Modus lässt sich die Anzahl der steigenden Flanken innerhalb einer Sekunde (=Frequenz) messen.

 

mode=DAPI_CNT48_MODE_PWM
Mit diesem Modus werden die „high“ und „low“ Zeit eines Signals gemessen. Dadurch kann anschließend das Verhältnis bestimmt werden (PWM).

 

Zusätzlich können alle Eingangszähler mit einem Eingangsfilter (mit einer oder-Verknüpfung) kombiniert werden. Hierzu stehen folgende Eingangsfilter zur Verfügung:

 

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

 

Bemerkung

Dieser Befehl wird nur von unserem Modul RO-CNT8 unterstützt.

 

Programmierbeispiel

DapiCnt48ModeSet(handle, 0, DAPI_CNT48_MODE_COUNT_RISING_EDGE | DAPI_CNT48_SUBMODE_RESET_WITH_READ | DAPI_CNT48_FILTER_20ns);
//Eingangszählerkanal 0 zählt alle Impulse <= 20ns bei steigender Flanke. Zusätzlich wird der Zähler nach Abfrage resettet.
DapiCnt48ModeSet(handle, 1, DAPI_CNT48_MODE_COUNT_RISING_EDGE | DAPI_CNT48_SUBMODE_RESET_ON_CH_7 | DAPI_CNT48_FILTER_500us);
//Eingangszählerkanal 1 zählt alle Impulse <= 500us bei steigender Flanke. Dieser Zähler kann mit einem externen Signal (ch7 = 1) resettet werden.
DapiCnt48ModeSet(handle, 2, DAPI_CNT48_MODE_PWM | DAPI_CNT48_FILTER_5ms);
//Eingangszählerkanal 2 misst alle low-/high Zeiten <= 5ms. Anschließend wird das Verhältnis bestimmt (PWM).

DapiCnt48ModeGet
Dieser Befehl liest den Zählmodus eines bestimmten Eingangszählerkanals zurück.

DapiCnt48ModeGet

 

Beschreibung

Dieser Befehl liest den Zählmodus eines bestimmten Eingangszählerkanals zurück.

 

Definition

ULONG DapiCnt48ModeGet(ULONG handle, ULONG ch);

 

Parameter

handle=Dies ist das Handle eines geöffneten Moduls
ch=Nummer des Eingangszählerkanals, dessen Modus ausgegeben werden soll (0, 1, 2, 3, .. )

 

Return-Wert

Zählmodus des Eingangszählerkanals.
(Nähere Informationen / Beschreibung der Bits -> siehe delib.h oder Manual „RO-Registerbelegung“)

 

Bemerkung

Dieser Befehl wird nur von unserem Modul RO-CNT8 unterstützt.

 

Programmierbeispiel

value = DapiCnt48ModeGet(handle, 0)
//Gibt den Zählmodus von Eingangszählerkanal 0 zurück
value = DapiCnt48ModeGet(handle, 3)
//Gibt den Zählmodus von Eingangszählerkanal 3 zurück

DapiCnt48CounterGet32
Dieser Befehl liest die ersten 32 Bit eines 48 Bit Eingangszählers.

DapiCnt48CounterGet32

 

Beschreibung

Dieser Befehl liest die ersten 32 Bit eines 48 Bit Eingangszählers.

 

Definition

ULONG DapiCnt48CounterGet32(ULONG handle, ULONG ch);

 

Parameter

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

 

Return-Wert

Ausgabe des Zählerwertes.

 

Bemerkung

Dieser Befehl wird nur von unseren Modulen RO-CNT8 und RO-CNT/IGR unterstützt.

 

Programmierbeispiel

value = DapiCnt48CounterGet32(handle, 0);
//gibt den Wert von Eingangszählerkanal 0 aus
value = DapiCnt48CounterGet32(handle, 3);
//gibt den Wert von Eingangszählerkanal 3 aus

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

DapiCnt48CounterGet48

 

Beschreibung

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

 

Definition

ULONGLONG DapiCnt48CounterGet48(ULONG handle, ULONG ch);

 

Parameter

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

 

Return-Wert

Ausgabe des Zählerwertes.

 

Bemerkung

Dieser Befehl wird nur von unseren Modulen RO-CNT8 und RO-CNT/IGR unterstützt.

 

Programmierbeispiel

value = DapiCnt48CounterGet48(handle, 0);
//gibt den Wert von Eingangszählerkanal 0 aus
value = DapiCnt48CounterGet48(handle, 3);
//gibt den Wert von Eingangszählerkanal 3 aus

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

DapiSpecialCommand – Dapi_Special_DI_Filter_Value_Set

 

Beschreibung

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

 

Definition

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_DI, DAPI_SPECIAL_DI_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.

 

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_FILTER_VALUE_SET, 5, 0);
// Setzt das Zeitintervall auf 5ms
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_DI, DAPI_SPECIAL_DI_FILTER_VALUE_SET, 150, 0);
// Setzt das Zeitintervall auf 150ms

DapiSpecialCommand - DapiSpecialDIFilterValueGet
Dieser Befehl gibt den vorher festgelegten Wert des Zeitintervalls zur Abtastung der digitalen Eingangskanäle in [ms] zurück

DapiSpecialCommand – Dapi_Special_DI_Filter_Value_Get

 

Beschreibung

Dieser Befehl gibt den vorher festgelegten Wert des Zeitintervalls zur Abtastung der digitalen Eingangskanäle in [ms] zurück.

 

Definition

ULONG DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_DI, DAPI_SPECIAL_DI_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_FILTER_VALUE_GET, 0, 0);
//Gibt das Zeitintervall zum Abtasten der digitalen Eingangskanäle zurück.

DapiSpecialCommand - Dapi_Special_DI_FF_Filter_Value_Set
Dieser Befehl setzt einen Filter [ms], in welchem Zeitintervall die Eingangs-Flip-Flops und die Eingangs-Zähler abgefragt werden

DapiSpecialCommand – Dapi_Special_DI_FF_Filter_Value_Set

 

Beschreibung

Dieser Befehl setzt einen Filter [ms], in welchem Zeitintervall die Eingangs-Flip-Flops und die Eingangs-Zähler abgefragt 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.

 

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 vorher festgelegten Wert des Zeitintervalls zur Abtastung der Eingangs-Flip-Flops und der Eingangs-Zähler in [ms] zurück

DapiSpecialCommand – Dapi_Special_DI_FF_Filter_Value_Get

 

Beschreibung

Dieser Befehl gibt den vorher festgelegten Wert des Zeitintervalls zur Abtastung der Eingangs-Flip-Flops und der Eingangs-Zähler in [ms] zurück.

 

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.

DapiSpecialCommand - DapiSpecialCNT48LatchGroup8
Dieser Befehl speichert die Zählerstände von 8 Eingangszähler gleichzeitig in ein Zwischenspeicher (Latch). So können anschließend alle Zählerstände des Latches nacheinander ausgelesen werden. Besonderheit hierbei ist, dass ein gleichzeitiges "Einfrieren" der Zählerstände möglich ist und die eingefrorenen Stände (Latch) dann (langsam) einzeln nacheinander ausgelesen werden können.

DapiSpecialCommand – DapiSpecialCNT48LatchGroup8

 

Beschreibung

Dieser Befehl speichert die Zählerstände von 8 Eingangszähler gleichzeitig in ein Zwischenspeicher (Latch).
So können anschließend alle Zählerstände des Latches nacheinander ausgelesen werden.
Besonderheit hierbei ist, dass ein gleichzeitiges „Einfrieren“ der Zählerstände möglich ist und die eingefrorenen Stände (Latch) dann (langsam) einzeln nacheinander ausgelesen werden können.

 

Definition

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

 

Parameter

handle=Dies ist das Handle eines geöffneten Moduls
ch=Gibt die Nummer des Eingangszählers an, ab dem die Zählerstande von 8 Eingangszählern gelatched werden (0, 8, 16, …)

 

Bemerkung

Dieser Befehl wird nur von unserem Modul RO-CNT8 unterstützt.

Bitte beachten Sie, dass nur die Zählerstände der Eingangszähler gelatched werden, bei denen zuvor der Modus

„DAPI_CNT48_SUBMODE_LATCH_COMMON“ gesetzt wurde. (-> DapiCnt48ModeSet)

 

Programmierbeispiel

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_CNT48, DAPI_SPECIAL_CNT48_LATCH_GROUP8, 0, 0)
// Zählerstände der Eingangszähler 0-7 werden gelatched
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_CNT48, DAPI_SPECIAL_CNT48_LATCH_GROUP8, 8, 0)
// Zählerstände der Eingangszähler 8-15 werden gelatched

DapiSpecialCommand - DapiSpecialCNT48ResetGroup8
Dieser Befehl resettet gleichzeitig die Zählerstände von 8 Eingangszählern.

DapiSpecialCommand – DapiSpecialCNT48ResetGroup8

 

Beschreibung

Dieser Befehl resettet gleichzeitig die Zählerstände von 8 Eingangszählern.

 

Definition

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

 

Parameter

handle=Dies ist das Handle eines geöffneten Moduls
ch=Gibt die Nummer des Eingangszählers an, ab dem die Zählerstande von 8 Eingangszählern resettet werden (0, 8, 16, …)

 

Bemerkung

Dieser Befehl wird nur von unserem Modul RO-CNT8 unterstützt.

 

Programmierbeispiel

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_CNT48, DAPI_SPECIAL_CNT48_RESET_GROUP8, 0, 0)
// Zählerstände der Eingangszähler 0-7 werden resettet
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_CNT48, DAPI_SPECIAL_CNT48_RESET_GROUP8, 8, 0)
// Zählerstände der Eingangszähler 8-15 werden resettet

DapiSpecialCommand - DapiSpecialCNT48ResetSingle
Dieser Befehl resettet den Zählerstand eines einzelnen Eingangszählers.

DapiSpecialCommand – DapiSpecialCNT48ResetSingle

 

Beschreibung

Dieser Befehl resettet den Zählerstand eines einzelnen Eingangszählers.

 

Definition

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

 

Parameter

handle=Dies ist das Handle eines geöffneten Moduls
ch=Gibt die Nummer des Eingangszählers an, dessen Zählerstand resettet werden soll (0, 1, 2, ..)

 

Bemerkung

Dieser Befehl wird nur von unserem Modul RO-CNT8 unterstützt.

 

Programmierbeispiel

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_CNT48, DAPI_SPECIAL_CNT48_RESET_SINGLE, 0, 0)
// Zählerstand von Eingangszähler 0 wird resettet
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_CNT48, DAPI_SPECIAL_CNT48_RESET_SINGLE, 1, 0)
// Zählerstand von Eingangszähler 1 wird resettet

DapiSpecialCommand - DapiSpecialCNT48DIGet1
Dieser Befehl liest den Eingangszustand (0/1) eines digitalen Eingangszählerkanals.

DapiSpecialCommand – DapiSpecialCNT48DIGet1

 

Beschreibung

Dieser Befehl liest den Eingangszustand (0/1) eines digitalen Eingangszählerkanals.

 

Definition

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

 

Parameter

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

 

Return-Wert

Zustand des Eingangszählers (0/1)

 

Bemerkung

Dieser Befehl wird nur von unserem Modul RO-CNT8 unterstützt.

 

Programmierbeispiel

value = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_CNT48, DAPI_SPECIAL_CNT48_DI_GET1, 0, 0)
// Liest Eingangszustand von Eingangszählerkanal 1
value = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_CNT48, DAPI_SPECIAL_CNT48_DI_GET1, 1, 0)
// Liest Eingangszustand von Eingangszählerkanal 2

Counter / Flip-Flop Ansteuerung

RO-Optoin Counter FF Ansteuerung

Anschlussbeispiel Optoin

Anschlussbeispiel

Manual

Handbuch USB-OPTOIN-8 / USB-RELAIS-8
Hardware- und Software-Beschreibung
Download

DELIB Treiberbibliothek

Manual der DELIB Treiberbibliothek
Dokumentation aller Befehle für die Treiberbibliothek
Download
  • Windows 11/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
DELIB (64-Bit)Treiberbibliothek für Windows
Für Windows 11/10, Windows 7, Windows 8, Vista, XP und 2000
Download

Installationsdatei für die 64-Bit Version der DELIB Treiberbibliothek.

Die folgenden Betriebssysteme sind kompatibel:
64-Bit

  • Windows 11/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

Mitgelieferte Software

ICT-Tool x64

  • Software um DEDITEC Modul auf den neusten Stand zu bringen
  • Konfiguration von Moduladressen einstellen
  • Konfiguration von Moduladressen einstellen
  • Konfiguration von modulspezifischen Einstellungen
  • Konfiguration von CAN Modulen einstellen
  • Ermöglicht manuelles Schalten eines Moduls
  • Konfiguration eines Watchdog-Sticks einstellen

ersetz folgende Software

  • Watchdog Configuration Utility x64
  • DT-Flasher x64
  • DELIB Module Demo x64
  • CAN Configuration Utility x64
  • DELIB Module Config x64
  • DELIB Configuration Utility x64

DELIB Command Line Interface x64
Ermöglicht das Ausführen von DELIB-Befehlen in der Kommandozeile

DELIB (32-Bit)Treiberbibliothek für Windows
Für Windows 11/10, Windows 7, Windows 8, Vista, XP und 2000
Download

Installationsdatei für die 32-Bit Version der DELIB Treiberbibliothek.

Die folgenden Betriebssysteme sind kompatibel:
32-Bit

    • Windows 11/10
    • Windows 7
    • Windows 8
    • Windows Server 2012
    • Windows Server 2008
    • Windows Vista
    • Windows XP
    • Windows Server 2003

64-Bit

  • Windows 11/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

Mitgelieferte Software

ICT-Tool x32

  • Software um DEDITEC Modul auf den neusten Stand zu bringen
  • Konfiguration von Moduladressen einstellen
  • Konfiguration von Moduladressen einstellen
  • Konfiguration von modulspezifischen Einstellungen
  • Konfiguration von CAN Modulen einstellen
  • Ermöglicht manuelles Schalten eines Moduls
  • Konfiguration eines Watchdog-Sticks einstellen

ersetz folgende Software

  • Watchdog Configuration Utility
  • DT-Flasher
  • DELIB Module Demo
  • CAN Configuration Utility
  • DELIB Module Config
  • DELIB Configuration Utility

Achtung:

Mit dieser Version der Treiberbibliothek können nur 32-Bit Anwendungen erstellt werden, die dann auf 32- und 64-Bit Systemen ausgeführt werden können.

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

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

Download

Hardware-Updates (Firmware)
Flash Files für das Module Config
Download

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

USB Kabel

  • Typ: Stecker A auf Stecker B
  • Länge: 1,8m

DEDITEC Treiber CD

DEDITEC Treiber CD mit vielen hilfreichen Tools und Handbüchern zur Inbetriebnahme Ihrer DEDITEC Produkte.

  • DELIB Treiberbibliothek für Windows
  • Test- und Konfigurationssoftware
  • Handbücher
  • Datenblätter
  • Beispielprogramme für C++, C#, VB, VB.Net, Delphi, LabVIEW

8 poliger Steckverbinder grün

Ermöglicht den Anschluss Ihrer Anwendung an das DEDITEC Modul.

  • Typ: Würth Elektronik / 691345510008
  • 100 % fehlsteckgeschützt
  • Anschluss für alle Leiterarten von 0,2mm² bis 3,3mm²
  • Schraubflansch

Optionaler Eingangsspannungsbereich 5V..15V DIL

Mit dieser Option kann der Eingangsspannungsbereich der OPTOIN Module auf 5V bis 15V reduziert werden. Es werden immer 8 Kanäle pro bestellter Anzahl von uns umgerüstet.

  • Eingangsspannungsbereich 5V bis 15V AC / DC
  • 8 Kanäle

USB-Watchdog-Stick mit 2 Relais für Schaltvorgänge

Dieser USB-WATCHDOG-STICK überwacht Ihren Steuerungs PC oder Server und kann im Falle eines Programmabsturzes selbstständig einen Reset der Hardware durchführen. Integrieren Sie einfach die Funktion des Watchdog Sticks in Ihre Applikation. Sobald eine Zeitüberschreitung auftritt und der Watchdog Stick nicht mehr periodisch zurückgesetzt wird, werden die beiden Relaisausgänge durchgeschaltet. Mit einer entsprechenden Anschlussverkabelung könnte bspw. der PC-Reset betätigt werden, ein externes SMS-Modem kann Warnungen versenden oder eine angeschlossene Sirene signalisiert einen Alarm. Mit Hilfe unseres kostenlosen Konfigurationstools können Sie definieren, auf welche Art und Weise die Relais im Fehlerfall schalten sollen.

  • USB 2.0 / USB 1.1 Interface
  • Watchdog Funktion
  • Überwachung Ihres Steuer PCs oder Servers
  • Timeoutzeiten von 10ms bis 10h einstellbar
  • Windows Watchdog API
  • 2 Schließer Relais (NO)
  • Anschlusskabel mit DSUB9 Buchse (ca. 1,8m)

230V Hutschienen-Relais

PLC-Interface für Grenzdauerströme bis 10A, bestehend aus Grundklemme mit Schraubanschluss und steckbarem Miniaturrelais. Montierbar auf Tragschiene NS 35/7,5.

  • Nennspannung: 230V AC / 230V DC
  • Schaltspannung: 250 V AC/DC
  • 1 Wechsler
  • Verpolschutz, Freilaufdiode
  • LED für Spannungsanzeige
  • Phoenix Contact, 2967675, PLC-RSC-230UC/21HC

8 poliger Steckverbinder grün

Ermöglicht den Anschluss Ihrer Anwendung an das DEDITEC Modul.

  • Typ: Würth Elektronik / 691345510008
  • 100 % fehlsteckgeschützt
  • Anschluss für alle Leiterarten von 0,2mm² bis 3,3mm²
  • Schraubflansch

Hutschiene

Hutschiene zur Montage unserer Steuer/Regeltechnik-Module.

  • Hutschiene nach DIN EN 50022
  • Typ: Phoenix Contact / 1208131
  • Abmessungen in mm: 450 x 35 x 7,5 (L x B x H)

Bewertungen

Es gibt noch keine Bewertungen.

Schreibe die erste Bewertung für „8 * Optokoppler-Eingänge über den USB-Bus abfragen“

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert

Nutzen Sie unsere Vorteile

Lebenslange
Updates

Kostenlose Soft- & Hardware(Firmware)-Updates.
Genießen Sie unseren lebenslangen Update-Service.

5 Jahre
Lieferverfügbarkeit

Wir bieten für unsere Produkte mindestens 5 Jahre Lieferverfügbarkeit.
Unsere Erfahrung zeigt dass es sogar ungefähr 10 Jahre sind.

Fragen zum Produkt? Produktberatung

Haben Sie vor dem Kauf noch technische oder kaufmännische Fragen zum Produkt?
Kontaktieren Sie uns dazu gerne vorab.

Kunden-
Modifikationen

Unsere Produkte dienen oft als Basis für Kundenspeziallösungen.
Sprechen Sie uns einfach an.

Wir sind
Immer für Sie da!

Seit der Gründung 2008 ist Dipl. Ing. Jürgen Siebert Geschäftsführer der DEDITEC GmbH. Gerne berät er Sie auch persönlich.

Produkt- & Service-Hotline: +49 (0) 22 32 / 50 40 8 – 40 Fragen zum Produkt oder zur Bestellung: support@deditec.de