Ethernet/USB Counter Modul mit 8/16 Eingangszählern und 2/4 Ausgangszählern

Name: Ethernet/USB Counter Modul mit 8/16 Eingangszählern und 2/4 Ausgangszählern
SKU: RO-(ETH/LC)/(USB)-CNT8-16
Availability: InStock

Bewertet mit 0 von 5

0 Kundenbewertungen

ab € 1.188,22

inkl. MwSt. plus Versandkosten

Neues Feature!

Erweiterter Eingangsfilter für Digital-IN / Timeout-Schutz-Funktion für Digital-Out.
Weitere Informationen dazu finden Sie unter den Reitern Beschreibung und Technische Daten!

Verfügbarkeit: Auf Lager SKU: RO-(ETH/LC)/(USB)-CNT8-16 Kategorie: RO-ETH/USB

Schnittstellen Variation

Anzahl Inkrementalgeber

Auswahl zurücksetzen

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

Das RO-(ETH/LC)/(USB)-CNT8-16 Modul verfügt über 8 oder 16 Zähler Eingänge mit einer max. Frequenz von 20 MHz und 2 bzw. 4 Impulsgeber Ausgängen mit einer max. Frequenz von 5 MHz. Zusätzlich sorgen Eingangsoptokoppler für eine sichere galvanische Trennung zwischen dem Counter Modul und Ihrer Applikation. Als Schnittstellenoption haben Sie die Wahl zwischen einer Open-Source Ethernet Anbindung mit galvanischer Trennung oder einem Standard USB 2.0 Anschluss.

Ethernet-Interface 10/100 Mbit mit galvanischer Trennung
Webinterface
Offenes Ethernet Protokoll
USB 2.0 Interface bis zu 480 Mbit
8/16 Eingangszähler je 48-Bit (max. 20 MHz)
8 verschiedene Eingangszählermodi (4 Hauptmodi und 4 Submodi)
2/4 Impulsgeber je 48-Bit (max. 5 MHz)

Frequenzmessung und Impulsgeber

Zählereingänge

Mit diesem Modul lassen sich Impulse zählen, die Periodendauer von Eingangssignalen bestimmen und Frequenzmessungen durchführen. Zusätzlich ermöglicht die galvanische Trennung der Eingänge den Anschluss von Signalen mit unterschiedlichen Potentialen in Bezug zum Counter Modul.

Impulsgeber

Der integrierte Impulsgeber kann Rechtecksignale bis 5MHz ausgegeben. Außerdem lassen sich bestimmte Zählereignisse mit diesem Ausgang verknüpfen.

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 kommt ein schraubenloses System des Herstellers WAGO Kontakttechnik zum Einsatz. Die 1-Leiter Federleisten sind 100% fehlsteckgeschützt und verfügen über eine Auswerf und Verriegelungsmechanik. Es lassen sich alle Leiterarten bis 1,5mm² anschließen.

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.

Fernschalten von IP Modulen

Unsere IP Module lassen sich bequem und einfach weltweit von zu Hause aus über das TCP-IP-Netz steuern. Dazu stehen Ihnen folgende kostenlosen Möglichkeiten zur Verfügung.

Module Config:

Unser Module Config ist mit in der DEDITEC Treiberbibliothek enthalten. Mit Hilfe dieser Software, können Sie Ihre DEDITEC Module konfigurieren, steuern und testen.

DEDITEC I/O-Control App:

Konfigurieren Sie Ihre DEDITEC Module ganz einfach per Smartphone. Mit unserer DEDITEC I/O-Control-App lassen sich unsere Module auch von unterwegs ansteuern.

Weboberfläche:

Unsere IP-Module lassen sich von jedem Browser aus bedienen. Dazu benötigen Sie lediglich die IP-Adresse des Modules.

Allgemein
Spannungsversorgung über externes Netzteil	+ 12V bis +24V DC (über zweipolige steckbare Schraubklemme)
LEDs	• Betriebsspannung • Interface-Aktivität • Status (nur bei Ethernet) • ERROR • Eingangszustandsänderung (nur bei digitalen Eingängen) • Timout Abschaltung • I/O Zugriff • Status Zählermodul • Activity -leuchtet beim Zugriff auf das Zählermodul • 8* Status Zähler-Eingang • 2* Status Impulsgeber-Ausgang
Steckverbinder	• Typ: Wago Kontakttechnik 713-1105/037-000 • Steckbare 10 polige Federleiste mit Verriegelungsmechanik • 100 % fehlsteckgeschützt • 1-Leiter Anschluss für alle Leiterarten bis 1,5mm²
Hutschienenaufnahme	TS 35
Betriebstemperatur	+10°C .. +50°C
Abmess. bei 16 Ausgängen	122mm x 85mm x 51,5mm (HxBxT)

Ethernet-Interface
Interface	• 10/100 Mbit Ethernet (galvanisch getrennt bis 1,5kV/AC 1 min) • Konfiguration über das DELIB Configuration Utility (IP-Adr., Netzmaske …)
IP-Adresse	• DHCP oder statisch
API-Bibliothek	• Einfache einzubindende C-Bibliothek für den Zugriff der Ein- bzw. Ausgänge
DIP Schalter	• DHCP ON/OFF • EEPROM Schreibschutz ON/OFF • BOOT mit EEPROM ON/OFF • SERVICE Mode ON/OFF
Zugriffsgeschwindigkeit	Durchschnittliche Zugriffszeit vom PC auf das Modul: 0,7 ms (Berechnet mit 1000 Zugriffen auf das Modul über die DELIB Treiberbibliothek mit dem Befehl DapiDoSet32)

USB-Interface
USB-Interface	• Anschluss: Typ B • USB 2.0 / USB 1.1 Interface mit bis zu 480Mbit
D-SUB 9	• Anschlussmöglichkeit des optionalen USB auf RS232 Konverters „RO-USB-Interface 1 Stick“ • Galvanische Trennung bis 500V
Zugriffsgeschwindigkeit	Durchschnittliche Zugriffszeit vom PC auf das Modul: 0,2 ms (Berechnet mit 1000 Zugriffen auf das Modul über die DELIB Treiberbibliothek mit dem Befehl DapiDoSet32)

Zählereingänge & Impulsgeber
Zähler Eingänge	• Max. Eingangsspannung: 15V DC bis 30V DC / optional auf 5V DC bis 15V DC änderbar • Max. Zählfrequenz: 20Mhz • Auflösung: 48-Bit • Max. Eingangsstrom: 14mA • Galvanische Trennung der Eingänge: 3,75kV AC/1min • Eingangsfilter je Kanal (per Software konfigurierbar)
Impulsgeber Ausgänge	• Ausgangsleistung: 5V / 25mA • Max. Zählfrequenz: 5Mhz • Auflösung: 48-Bit • Galvanische Trennung zur Spannungsversorgung vom Modul: 1kV • Anzahl der zu erzeugenden Impulse einstellbar: (0= unendlich viele) • Einstellung der low-Zeit (10ns Schritte) • Einstellung der high-Zeit (10ns Schritte)PWM Ausgänge mit z.B. folgenden Modi: • 0,5kHz – Frequenz PWM Verhältnis mit 0,01% Auflösung • 5kHz – Frequenz PWM Verhältnis mit 0,1% Auflösung • 50kHz – Frequenz PWM Verhältnis mit 1% Auflösung

Die unterschiedlichen Zählmodi
Hauptmodus 1	• Zählen von Impulsen: Mit diesem Modus lassen sich Impulse anhand von einer steigenden Flanke zählen. Ein Zurücksetzen ist hierbei per Software möglich.
Hauptmodus 2	• Periodendauer Bestimmung: In diesem Modus wird die Periodendauer „T“ des angelegten Eingangssignals gemessen. Ein interner 100MHz Zähler dient hierbei als Zeitbasis. Bei einer steigenden Flanke des Eingangssignals wird der 48 Bit Zähler in einen Zwischenspeicher gelegt (Latch) und kann ausgewertet werden, während das nächste Signal wieder gezählt wird.
Hauptmodus 3	• Anzahlmessung/Frequenzmessung: Mit diesem Modus lässt sich die Anzahl der steigenden Flanken des Eingangssignals innerhalb einer bestimmten Zeit messen. Hier lassen sich die Zeiten 1ms, 10ms, 100ms, 1sec. per Software konfigurieren. So lassen sich z.B. Frequenzmessungen durchführen.
Hauptmodus 4	• PWM Messungen: Mit diesem Modus werden mit zwei unterschiedlichen Zählern die „high“-Zeit und die „low“-Zeit eines Signals gemessen. Dadurch lässt sich das high / low-Verhältnis bestimmen (PWM). Durch die Verwendung eines internen 100MHz Zählers lassen sich hier äusserst genaue PWM Verhältnisse bestimmen.
Submodus 1	• Zählen von Impulsen ohne „reset bei read“: Mit diesem Modus lassen sich Impulse anhand einer steigenden Flanke zählen. Beim Auslesen des Zählers wird der Zähler nicht zurückgesetzt, sondern bleibt bei seinem aktuellen Wert.
Submodus 2	• Zählen von Impulsen mit „reset bei read“: Mit diesem Modus lassen sich Impulse anhand einer steigenden Flanke zählen. Beim Auslesen des Zählers wird der Zähler gleichzeitig zurückgesetzt.
Submodus 3	• Zählen von Impulsen mit „reset wenn Kanal 7 = 1“: 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.
Submodus 4	• Read Latch-Counter: Mit dem Latch-Befehl 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.

Zusätzliche Informationen

Gewicht	n. v.
Schnittstellen Variation	Ethernet, USB
Anzahl Inkrementalgeber	8, 16

Konfiguration

Konfiguration von Ethernet-Modulen

Module mit einem 10/100 Mbit Ethernet-Interface können direkt an einem PC oder an einem Netzwerk-LAN angeschlossen werden. Für die Konfiguration stehen folgende Möglichkeiten zur Auswahl:

1. DT Module Config

Mit dem DT Module Config lässt sich Ihr Ethernet Modul nicht nur schnell und einfach konfigurieren, Sie können sich auch alle wichtigen Modulinformationen auf nur einen Blick anzeigen lassen.

Modul-Name
Modul-ID
Firmware-Revision

Identifikation

Identifizieren Sie Ihr im momentan angesprochenes Modul mit Hilfe von auf dem Board befindlichen LEDs. Dies ist besonders hilfreich, wenn mehrere Module gleichzeitig in betrieb sind.

LAN Netzwerkinformationen

Alle wichtigen LAN Netzwerkinformationen auf einen Blick. Auf dieser Informationsseite, finden Sie die aktuellen LAN-Einstellungen Ihres Modules.

LAN Netzwerkkonfiguration

Binden Sie Ihr Modul mit nur wenigen Klicks in das Heim- bzw. Firmennetzwerk ein oder steuern Sie es direkt per 1 zu 1 Verbindung an. Folgende Modulinformationen lassen sich mit dem DT Module Config abfragen und ändern.

Board Name
Netzwerk-Schutz
DHCP on/off
IP-Adresse
Netzmaske
Std. Gateway
TCP-Port

2. Weboberfläche

Das Ethernet-Modul verfügt über einen eigenen Web-Server, über den folgende Parameter geändert werden können:

IP-Adresse
IP-Adresse
Netzmaske
Std. Gateway
DNS Server

3. DELIB Configuration Utiliy

Mit dem DELIB Configuration Utility lässt sich das Netzwerk automatisch nach DEDITEC Produkten durchsuchen. Alle gefundenen Module lassen sich anschließend mit wenigen Klicks konfigurieren. Folgende Parameter können angezeigt und z.T. verändert werden:

MAC Adresse
DHCP oder statische IP
IP-Adresse
Modulname
Produkttyp
Netzmaske
Std.-Gateway
Port
Verbindungstimeout
Verschlüsselung
Namensvergabe für I/Os

Erweiterte Optionen

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

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.

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.

Das DELIB Configuration Utility wird mit der DELIB 2.0 Treiberbibliothek installiert und kann hier herunter geladen werden:

DELIB Treiberbibliothek

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

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 DELIB-Configuration Utility. 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.

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

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

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

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

Puls-Gen-Funktionen

DapiPulseGenSet

Dieser Befehl generiert eine gewisse Anzahl an Impulsen mit vorgegebenen low- und high-Zeiten.

DapiPulseGenSet

Beschreibung

Dieser Befehl generiert eine gewisse Anzahl an Impulsen mit vorgegebenen low- und high-Zeiten.

Definition

void DapiPulseGenSet(ULONG handle, ULONG ch, ULONG mode, ULONG par0, ULONG par1, ULONG par2);

Parameter

handle=Dies ist das Handle eines geöffneten Moduls
ch=Gibt die Nummer des zu setzenden Ausgangs an (0, 1, 2, .. )
mode=Modus, mit dem Impulse generiert werden (muss immer 0 sein).
par0=Anzahl der zu erzeugenden Impulsen (par0=0 -> unendlich viele Impulse)
par1=Low-Zeit des Impulses ( t[ns] / 10 – 1)
par2=High-Zeit des Impulses ( t[ns] / 10 – 1)

Beispiel für das Einstellen der low-/high-Zeit (Par1/Par2)
500ns -> 500 / 10 – 1 = 49(dez)
7us -> 7.000 / 10 – 1 = 699(dez)
2,5ms -> 2.500.000 / 10 – 1 = 249.999(dez)

Return-Wert

Keiner

Programmierbeispiel

DapiPulseGenSet(handle, 0, 0, 10, 29, 69);
// generiert 10 Impulse an Pulsgenerator-Ausgang 0 mit einer low-Zeit von 300ns und einer high-Zeit von 700ns.
DapiPulseGenSet(handle, 3, 0, 100, 7999, 9999);
// generiert 100 Impulse an Pulsgenerator-Ausgang 3 mit einer low-Zeit von 80us und einer high-Zeit von 100us.
DapiPulseGenSet(handle, 10, 0, 0, 249999, 299999);
// generiert unendlich viele Impulse an Pulsgenerator-Ausgang 10 mit einer low-Zeit von 2,5ms und einer high-Zeit von 3ms.

Software FIFO-Funktionen

DapiSpecialCommand - DapiSpecialCMDSWFifo

Dieser Befehl dient zum Einstellen der Software FIFO der NET-Serie

DapiSpecialCommand-DapiSpecialCMDSWFifo

Beschreibung

Dieser Befehl dient zum Einstellen der Software FIFO.
DAPI_SPECIAL_CMD_SW_FIFO-Befehle funktionieren nur bei der NET-Serie.

Definition

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO, cmd, fifo_instance, par2);

Parameter

handle = Dies ist das Handle eines geöffneten Moduls
cmd = auszuführende Funktion
fifo_instance = Gibt die Instanz des Software FIFO an. Bislang gibt es nur Instanz 0
par2 = Wert, der an die Funktion übergeben wird

Bemerkung

Definieren Sie als erstes immer das Submodul mit dem DapiSpecialSWFifoSetSubmodule-Befehl!

DapiSpecialCommand - DapiSpecialSWFifoSetSubmodule

Dieser Befehl gibt an, an welches Submodul die Daten des Software FIFO übergeben werden

DapiSpecialCommand-DapiSpecialSWFifoSetSubmodule

Beschreibung

Dieser Befehl gibt an, an welches Submodul die Daten des Software FIFO übergeben werden.

Definition

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO, cmd, fifo_instance, par2);

Parameter

cmd = DAPI_SPECIAL_SW_FIFO_SET_SUBMODULE
fifo_instance = Gibt die Instanz des Software FIFO an
par2 = gibt die Nummer des Submoduls an (0, 1, 2, 3, …)

Programmierbeispiel

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_SET_SUBMODULE, fifo_instance, 2);
//Der Software FIFO überträgt die Daten an Submodul 2.

DapiSpecialCommand - DapiSpecialSWFifoGetSubmodule

Dieser Befehl gibt die Nummer des Submoduls, auf welches die Daten übertragen werden, wieder

DapiSpecialCommand-DapiSpecialSWFifoGetSubmodule

Beschreibung

Dieser Befehl gibt die Nummer des Submoduls, auf welches die Daten übertragen werden, wieder.

Definition

ULONG DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO, cmd, fifo_instance, 0);

Parameter

cmd = DAPI_SPECIAL_SW_FIFO_GET_SUBMODULE
fifo_instance = Gibt die Instanz des Software FIFO an

Return-Wert

Nummer des Submodules (0, 1, 2, 3, …)

Programmierbeispiel

unsigned long ret = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_GET_SUBMODULE, fifo_instance, 0);
printf(„Submodule = %lu\n“, ret);
//Die Nummer des Submoduls wird ausgelesen und dargestellt.

DapiSpecialCommand - DapiSpecialSWFifoActivate

Dieser Befehl aktiviert die automatische Ausgabe des D/A Wandlers

DapiSpecialCommand-DapiSpecialSWFifoActivate

Beschreibung

Dieser Befehl aktiviert die Fifo-Datenübertragung innerhalb der NET-Module.

Definition

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO, cmd, fifo_instance, 0);

Parameter

cmd = DAPI_SPECIAL_SW_FIFO_ACTIVATE
fifo_instance = Gibt die Instanz des Software FIFO an

Programmierbeispiel

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_ACTIVATE, fifo_instance, 0);
//Das automatische Ausgeben des D/A Wandlers wird aktiviert.

DapiSpecialCommand - DapiSpecialSWFifoDeactivate

Dieser Befehl deaktiviert die automatische Ausgabe des D/A Wandlers

DapiSpecialCommand-DapiSpecialSWFifoDeactivate

Beschreibung

Dieser Befehl deaktiviert die Fifo-Datenübertragung innerhalb der NET-Module.

Definition

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO, cmd, fifo_instance, 0);

Parameter

cmd = DAPI_SPECIAL_SW_FIFO_DEACTIVATE
fifo_instance = Gibt die Instanz des Software FIFO an

Programmierbeispiel

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_DEACTIVATE, fifo_instance, 0);
//Das automatische Ausgeben des D/A Wandlers wird deaktiviert.

DapiSpecialCommand - DapiSpecialSWFifoGetActivity

Mit diesem Befehl wird der Status der Übertragung des FIFO an den D/A Wandler abgerufen (ob aktiv oder inaktiv)

DapiSpecialCommand-DapiSpecialSWFifoGetActivity

Beschreibung

Mit diesem Befehl wird der Status der Übertragung des FIFO an den D/A Wandler abgerufen (ob aktiv oder inaktiv).

Definition

ULONG DapiSpecialCommand(handle, DAPI_SPECIAL_SW_FIFO, cmd, fifo_instance, 0);

Parameter

cmd = DAPI_SPECIAL_SW_FIFO_GET_ACTIVITY
fifo_instance = Gibt die Instanz des Software FIFO an

Return-Wert

Return = 0 (Übertragung ist deaktiviert)
Return = 1 (Übertragung ist aktiviert)

Programmierbeispiel

unsigned long ret = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_GET_ACTIVITY, fifo_instance, 0);
printf(„Status = %lu\n“, ret);
//Übertragungs-Status wird abgerufen

DapiSpecialCommand - DapiSpecialSWFifoIOActivate

Dieser Befehl aktiviert die FIFO- I/O Ein-/Ausgabe

DapiSpecialCommand-DapiSpecialSWFifoIOActivate

Beschreibung

Dieser Befehl aktiviert die FIFO- I/O Ein-/Ausgabe.

Definition

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO, cmd, fifo_instance, 0);

Parameter

cmd = DAPI_SPECIAL_SW_FIFO_IO_ACTIVATE
fifo_instance = Gibt die Instanz des Software FIFO an

Programmierbeispiel

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_IO_ACTIVATE, fifo_instance, 0);
//Das automatische Ausgeben des FIFO an das Modul wird aktiviert.

DapiSpecialCommand - DapiSpecialSWFifoIODeactivate

Dieser Befehl deaktiviert die FIFO- I/O Ein-/Ausgabe

DapiSpecialCommand-DapiSpecialSWFifoIODeactivate

Beschreibung

Dieser Befehl deaktiviert die FIFO- I/O Ein-/Ausgabe.

Definition

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO, cmd, fifo_instance, 0);

Parameter

cmd = DAPI_SPECIAL_SW_FIFO_IO_DEACTIVATE
fifo_instance = Gibt die Instanz des Software FIFO an

Programmierbeispiel

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_IO_DEACTIVATE, fifo_instance, 0);
//Das automatische Ausgeben des FIFO an das Modul wird deaktiviert.

DapiSpecialCommand - DapiSpecialSWFifoInitAndClear

Dieser Befehl löscht vorhandene Daten aus dem Software FIFO Speicher und bringt den FIFO-Mechanismus in den Ausgangszustand zurück

DapiSpecialCommand-DapiSpecialSWFifoInitAndClear

Beschreibung

Dieser Befehl löscht vorhandene Daten aus dem Software FIFO Speicher und bringt den FIFO-Mechanismus in den Ausgangszustand zurück.

Definition

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO, cmd, fifo_instance, 0);

Parameter

cmd = DAPI_SPECIAL_SW_FIFO_INIT_AND_CLEAR
fifo_instance = Gibt die Instanz des Software FIFO an

Programmierbeispiel

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_INIT_AND_CLEAR, fifo_instance, 0);
//Vorhandene Daten werden aus dem FIFO Speicher gelöscht.

DapiSpecialCommand - DapiSpecialSWFifoSetChannel

Dieser Befehl gibt unter Angabe von Start- und Endkanal an, in welche A/D Kanäle die Daten des FIFO übertragen werden sollen

DapiSpecialCommand-DapiSpecialSWFifoSetChannel

Beschreibung

Dieser Befehl gibt unter Angabe von Start- und Endkanal an, in welche A/D Kanäle die Daten des FIFO übertragen werden sollen.

Definition

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO, cmd, fifo_instance, ch);

Parameter

cmd = DAPI_SPECIAL_SW_FIFO_SET_CHANNEL
fifo_instance = Gibt die Instanz des Software FIFO an
ch = Angabe des Start- und Endkanals

Programmierbeispiel

unsigned long ch_start = 0; //Start with D/A Channel 0
unsigned long ch_end = 1; //End with D/A Channel 1

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_SET_Channel, fifo_instance,
((ch_end << 8) & 0xff00) | (ch_start & 0xff);
//Der Start- und Endkanal wird festgelegt

DapiSpecialCommand - DapiSpecialSWFifoGetChannel

Dieser Befehl zeigt die D/A Kanäle auf welches die Daten übertragen werden

DapiSpecialCommand-DapiSpecialSWFifoGetChannel

Beschreibung

Dieser Befehl zeigt die D/A Kanäle auf welches die Daten übertragen werden.

Definition

ULONG DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO, cmd, fifo_instance, 0);

Parameter

cmd = DAPI_SPECIAL_SW_FIFO_GET_CHANNEL
fifo_instance = Gibt die Instanz des Software FIFO an

Return-Wert

Nummer der A/D Kanäle
Bit 0-7 Startkanal
Bit 8-15 Endkanal

Programmierbeispiel

unsigned long ret = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_GET_CHANNEL, fifo_instance, 0);
printf(„Channel = %lu\n“, ret);
//Zeigt auf welche A/D Kanäle die Daten übertragen werden.

DapiSpecialCommand - DapiSpecialSWFifoSetFrequencyHz

Dieser Befehl gibt an, in welchem Frequenzintervall (in Hertz) aus dem FIFO in das Modul geschrieben wird

DapiSpecialCommand-DapiSpecialSWFifoSetFrequencyHz

Beschreibung

Dieser Befehl gibt an, in welchem Frequenzintervall (in Hertz) aus dem FIFO in das Modul geschrieben wird.

Definition

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO, cmd, fifo_instance, par2);

Parameter

cmd = DAPI_SPECIAL_SW_FIFO_SET_FREQUENCY_HZ
fifo_instance = Gibt die Instanz des Software FIFO an
par2 = Frequenzintervall in Hertz (Hz)

Programmierbeispiel

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_SET_FREQUENCY_HZ, fifo_instance, 10);
//Setzt das Frequenzintervall auf 10Hz.

DapiSpecialCommand - DapiSpecialSWFifoGetFrequencyHz

Dieser Befehl gibt das vorher eingestellte Frequenzintervall in Hertz wieder

DapiSpecialCommand-DapiSpecialSWFifoGetFrequencyHz

Beschreibung

Dieser Befehl gibt das vorher eingestellte Frequenzintervall in Hertz wieder.

Definition

ULONG DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO, cmd, fifo_instance, 0);

Parameter

cmd = DAPI_SPECIAL_SW_FIFO_GET_FREQUENCY_HZ
fifo_instance = Gibt die Instanz des Software FIFO an

Return-Wert

Frequenzintervall in Hertz (Hz)

Programmierbeispiel

unsigned long ret = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_GET_FREQUENCY_HZ, fifo_instance, 0);
printf(„Frequency = %lu (Hz)\n“, ret);
//Zeigt das vorher eingestellte Frequenzintervall an.

DapiSpecialCommand - DapiSpecialSWFifoGetBytesFree

Dieser Befehl dient zum Auslesen der freien Bytes im Software FIFO Buffer

DapiSpecialCommand-DapiSpecialSWFifoGetBytesFree

Beschreibung

Dieser Befehl dient zum Auslesen der freien Bytes im Software FIFO Buffer.

Definition

ULONG DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO, cmd, fifo_instance, 0);

Parameter

cmd = DAPI_SPECIAL_SW_FIFO_GET_BYTES_FREE
fifo_instance = Gibt die Instanz des Software FIFO an

Return-Wert

Freie Bytes des Software FIFO

Programmierbeispiel

unsigned long ret = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_GET_BYTES_FREE, fifo_instance, 0);
printf(„Freier Speicher = %lu\n“, ret);
//Ausgabe der noch freien Bytes des Speichers.

DapiSpecialCommand - DapiSpecialSWFifoGetBytesPerSample

Dieser Befehl gibt an wieviel Bytes für das Schreiben in den D/A Wandler notwendig sind

DapiSpecialCommand-DapiSpecialSWFifoGetBytesPerSample

Beschreibung

Dieser Befehl gibt an wieviel Bytes für das Schreiben in den D/A Wandler notwendig sind.
Beispiel: Werden bei einem 16 Bit (2Byte) D/A Wandler 3 D/A Kanäle beschrieben, werden also 3×2 Bytes pro Sample benötigt. Der Wert 6 wird wiedergeben.

Definition

ULONG DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO, cmd, fifo_instance, 0);

Parameter

cmd = DAPI_SPECIAL_SW_FIFO_GET_BYTES_PER_SAMPLE
fifo_instance = Gibt die Instanz des Software FIFO an

Return-Wert

Benötigte Bytes pro Sample

Programmierbeispiel

unsigned long ret = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_GET_BYTES_PER_SAMPLE, fifo_instance, 0);
printf(„Benoetigte Bytes = %lu\n“, ret);
//Ausgabe der notwendigen Bytes pro Sample.

DapiSpecialCommand - DapiSpecialSWFifoSetMode

Dieser Befehl setzt den Software FIFO Mode

DapiSpecialCommand-DapiSpecialSWFifoSetMode

Beschreibung

Dieser Befehl setzt den Software FIFO Mode. In der aktuellen Firmware wird dieser Befehl noch nicht unterstützt.

Definition

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO, cmd, fifo_instance, par2);

Parameter

cmd = DAPI_SPECIAL_SW_FIFO_SET_MODE
fifo_instance = Gibt die Instanz des Software FIFO an
par2 = Software FIFO Mode

Programmierbeispiel

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_SET_MODE, fifo_instance, 0);
//Der Software FIFO Mode wird gesetzt.

DapiSpecialCommand - DapiSpecialSWFifoGetMode

Dieser Befehl gibt den vorher eingestellten FIFO Mode wieder

DapiSpecialCommand-DapiSpecialSWFifoGetMode

Beschreibung

Dieser Befehl gibt den vorher eingestellten FIFO Mode wieder. Aktuell wird dieser in der Firmware noch nicht unterstützt.

Definition

ULONG DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO, cmd, fifo_instance, 0);

Parameter

cmd = DAPI_SPECIAL_SW_FIFO_GET_MODE
fifo_instance = Gibt die Instanz des Software FIFO an

Return-Wert

FIFO Software Mode

Programmierbeispiel

unsigned long ret = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_GET_MODE, fifo_instance, 0);
printf(„Mode = %lu\n“, ret);
//Gibt den vorher eingestellten FIFO Mode wieder.

DapiSpecialCommand - DapiSpecialSWFifoGetStatus

Mit diesem Befehl werden Status Informationen abgerufen. In der Aktuellen Firmware wird dies noch nicht unterstützt

DapiSpecialCommand-DapiSpecialSWFifoGetStatus

Beschreibung

Mit diesem Befehl können Statuswerte abgerufen werden.

Definition

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO, cmd, fifo_instance, 0);

Parameter

cmd = DAPI_SPECIAL_SW_FIFO_GET_STATUS
fifo_instance = Gibt die Instanz des Software FIFO an

Return-Wert

	Beschreibung (FIFO-Status erzeugt einen Return-Wert…)	Return-Wert in hex
DAPI_SPECIAL_SW_FIFO_STATUS_IS_ACTIVE	… wenn die Ausgabe des D/A Wandlers aktiv ist	0x01
DAPI_SPECIAL_SW_FIFO_STATUS_IO_IS_ACTIVE	… wenn die Ausgabe des FIFO I/O aktiv ist	0x02
DAPI_SPECIAL_SW_FIFO_STATUS_FIFO_OVERFLOW	… wenn zuviele Daten in den FIFO geschrieben werden	0x04
DAPI_SPECIAL_SW_FIFO_STATUS_FIFO_UNDERRUN	… wenn der FIFO leer läuft	0x08
DAPI_SPECIAL_SW_FIFO_STATUS_FIFO_OUT_OF_SYNC	… wenn die FIFO-Kommunikation innerhalb der Module unterbrochen ist	0x10

Programmierbeispiel

unsigned long ret;

ret = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO,DAPI_SPECIAL_SW_FIFO_GET_STATUS, fifo_instance, 0);
if((ret & 0x01) != 0) {printf(„is_active“);}
if((ret & 0x02) != 0) {printf(„io_is_active“);}
if((ret & 0x04) != 0) {printf(„fifo_overflow“);}
if((ret & 0x08) != 0) {printf(„fifo_underrun“);}
if((ret & 0x10) != 0) {printf(„fifo_out_of_sync);}

DapiSpecialCommand - DapiSpecialCMDAD

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

DapiSpecialCommand-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_RO_AD_FIFO_INIT
par0=nicht definiert

FIFO aktivieren
cmd=DAPI_SPECIAL_RO_AD_FIFO_ACTIVATE
par0=nicht definiert

FIFO deaktivieren
cmd=DAPI_SPECIAL_RO_AD_FIFO_DEACTIVATE
par0=nicht definiert

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

FIFO für einen A/D-Wandler Kanal setzen
cmd=DAPI_SPECIAL_RO_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_RO_AD_FIFO_GET_STATUS
par0=nicht definiert

Return-Wert

cmd=DAPI_SPECIAL_RO_AD_FIFO_INIT
kein return Wert

cmd=DAPI_SPECIAL_RO_AD_FIFO_ACTIVATE
kein return Wert

cmd=DAPI_SPECIAL_RO_AD_FIFO_DEACTIVATE
kein return Wert

cmd=DAPI_SPECIAL_RO_AD_FIFO_SET_INTERVAL_MS
kein return Wert

cmd=DAPI_SPECIAL_RO_AD_FIFO_SET_CHANNEL
kein return Wert

cmd=DAPI_SPECIAL_RO_AD_FIFO_GET_STATUS
return=aktueller FIFO-Status

Wert [hex] Bedeutung Erklärung 0x80 RO_FIFO_STATUS_MASK_MEASURE_ENABLED FIFO ist aktiv 0x40 RO_FIFO_STATUS_MASK_TEST_DATA
0x20 RO_FIFO_STATUS_MASK_OVERFLOW FIFO Buffer ist voll 0x10 RO_FIFO_STATUS_MASK_UNDERRUN
0x08 RO_FIFO_STATUS_FULL_256_BYTE 256 Byte Daten vorhanden 0x04 RO_FIFO_STATUS_FULL_64_BYTE 64 Byte Daten vorhanden 0x02 RO_FIFO_STATUS_FULL_16_BYTE 16 Byte Daten vorhanden 0x01 RO_FIFO_STATUS_FULL_1_BYTE 1 Byte Daten vorhanden

Programmierbeispiel

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_AD, DAPI_SPECIAL_RO_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_RO_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_RO_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_RO_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_RO_AD_FIFO_ACTIVATE, DAPI_SPECIAL_AD_CH0_CH15, 0);
// starts / activates the recording

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

DapiWriteFifo

Dieser Befehl schreibt Datensätze in den Software FIFO

DapiWriteFifo

Beschreibung

Dieser Befehl schreibt Datensätze in den Software FIFO.

Definition

DapiWriteFifo(ULONG handle, ULONG fifo_instance, ULONG type, UCHAR * buffer, ULONG buffer_length);

Parameter

handle=Dies ist das Handle eines geöffneten Moduls
fifo_instance=Gibt die Instanz des Software FIFO an
type=Gibt den FIFO-Typ an
buffer=Buffer für den zu sendenden Datensatz
buffer_length=Länge des Buffers

Programmierbeispiel

DapiWriteFifo(handle, fifo_instance, 0, buff, pos);
//Schreibt den Datensatz in den Software FIFO.

DapiReadFifo

Dieser Befehl liest den Software-FIFO von RO-Modulen aus

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 fifo_instance, ULONG type, UCHAR * buffer, ULONG buffer_length);

Parameter

handle=Dies ist das Handle eines geöffneten Moduls
fifo_instance=Gibt die Instanz des Software FIFO an
type=Gibt den FIFO-Typ an
buffer=Buffer für den zu empfangenden Datensatz
buffer_length=Länge des Buffers

Return-Wert

Länge der ausgelesenen FIFO-Datenstätze

Aufbau eines FIFO-Datensatz

(Beispiel mit 2 aktiven AD Kanälen, AD0 und AD4)

Byte || Bedeutung || Wert [hex]

0 RO_FIFO_ID_START 0xf0

1 FIFO-Typ
2 Zeitstempel (Bit0..Bit7)
3 Zeitstempel (Bit8..Bit15)
4 Aktive A/D-Kanäle (Bit0..Bit7) 0x11

5 Aktive A/D-Kanäle (Bit8..Bit15) 0x00

6 A/D Wert Kanal 0 (Bit0..Bit7)
7 A/D Wert Kanal 0 (Bit8..Bit15)
8 A/D Wert Kanal 4 (Bit0..Bit7)
9 A/D Wert Kanal 4 (Bit8..Bit15)
10 RO_FIFO_ID_END 0xf1

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 dem Befehl „DapiSpecialCMDAD“ aktiviert, bzw. initialisiert werden muss.

Programmierbeispiel

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

Weboberfläche – Interface

Alle DEDITEC Ethernet-Module verfügt über eine Weboberfläche, die es Ihnen erlaubt, Einstellungen bequem über Ihren Webbrowser vorzunehmen und bietet Ihnen außerdem direkten Zugriff auf die I/Os.

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:

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 Ethernet-Modul gegen Fremdzugriffe schützen.

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.

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.

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.

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.

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.

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.

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.

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.

I/O-Control APP für Android™

Von unterwegs aus die digitalen und analogen I/Os unserer Ethernet-Module 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

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.

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.

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

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.

Blockschaltbild RO-CNT8

Anschlussbeispiel Counter

Anschlussbeispiel

Schraubenloses Steckverbindersystem

Die kundenseitige Anschlussverdrahtung der Ein- und Ausgänge erfolgt über schraubenlose, steckbare Klemmleisten. Der Leiteranschluss erfolgt durch ein sog. Betätigungswerkzeug.
Eine Verriegelungs- und Auswerfmechanik erleichtert das Stecken und Entfernen der kompletten Klemmleiste.

Handhabung

Schritt 1

Betätigungswerkzeug dem Lieferumfang entnehmen.

Schritt 2

Betätigungswerkzeug in Leiteranschlussrichtung kräftig in die seitliche Öffnung stecken.

Schritt 3

Den abisolierten Leiter nun in den geöffneten Klemmkontakt stecken.

Schritt 4

Betätigungswerkzeug wieder heraus ziehen.

Schritt 5

Ordnungsgemäßen Anschluss des Leiters überprüfen. Dieser sollte sich nun nicht mehr ohne Weiteres herausziehen lassen.

Manual

Handbuch RO-Serie

Hardware- und Software-Beschreibung

Download

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

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

DT-Flasher x64
Software um DEDITEC Modul auf den neusten Stand zu bringen
DELIB Configuration Utility x64
Konfiguration von Moduladressen einstellen
DELIB Module Config x64
Konfiguration von modulspezifischen Einstellungen
CAN Configuration Utility x64
Konfiguration von CAN Modulen einstellen
DELIB Module Demo x64
Ermöglicht manuelles Schalten eines Moduls
DELIB Command Line Interface x64
Ermöglicht das Ausführen von DELIB-Befehlen in der Kommandozeile
Watchdog Configuration Utility x64
Konfiguration eines Watchdog-Sticks einstellen

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

DT-Flasher
Software um DEDITEC Modul auf den neusten Stand zu bringen
DELIB Configuration Utility
Konfiguration von Moduladressen einstellen
DELIB Module Config
Konfiguration von modulspezifischen Einstellungen
CAN Configuration Utility
Konfiguration von CAN Modulen einstellen
DELIB Module Demo
Ermöglicht manuelles Schalten eines Moduls
DELIB Command Line Interface
Ermöglicht das Ausführen von DELIB-Befehlen in der Kommandozeile
Watchdog Configuration Utility
Konfiguration eines Watchdog-Sticks einstellen

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

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

2 poliger Steckverbinder

Ermöglicht den Anschluss der Spannungsversorgung an das DEDITEC Modul.

Typ: Phoenix Contact 1783287
100 % fehlsteckgeschützt
Für alle Leiterarten von 0,2mm² bis 2,5mm²

10 poliger Steckverbinder

Wird benötigt zum Anschluss Ihrer Anwendung an das DEDITEC Modul.

Typ: Wago Kontakttechnik 713-1105/037-000
Steckbare Federleiste mit Verriegelungsmechanik
100 % fehlsteckgeschützt
1-Leiter Anschluss für alle Leiterarten bis 1,5mm²

Betätigungswerkzeug für Wago Steckverbinder

Dient zum Öffnen und Schließen der Klemmkontake an den Wago Steckverbindern.

Typ: Wago Kontakttechnik 734-231

USB Kabel

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

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)

Netzteil 24V/2A für Hutschienenmontage

Das DR-4524 von Mean Well ist ein 48W Netzteil zur Hutschienenmontage für industrielle Anwendungen. Es bietet Schutz vor Kurzschluss, Überlast, Überspannung und Überhitzung.

Eingangsspannungsbereich: 85V.. 264V AC / 120V DC .. 370V DC
Ausgangsspannung: 24V DC
Ausgangsstrom: 2A
Nennleistung: 48W

2 poliger Steckverbinder

Ermöglicht den Anschluss der Spannungsversorgung an das DEDITEC Modul.

Typ: Phoenix Contact 1783287
100 % fehlsteckgeschützt
Für alle Leiterarten von 0,2mm² bis 2,5mm²

10 poliger Steckverbinder

Wird benötigt zum Anschluss Ihrer Anwendung an das DEDITEC Modul.

Typ: Wago Kontakttechnik 713-1105/037-000
Steckbare Federleiste mit Verriegelungsmechanik
100 % fehlsteckgeschützt
1-Leiter Anschluss für alle Leiterarten bis 1,5mm²

Zugentlastungsplatte für 10 polige Wago Steckverbinder

Eine mittig zwischen die Leitereinführungen montierbare Zugentlastungsplatte erleichtert den Steck- und Trennvorgang und erlaubt den einfachen Zugang zu den Betätigungsöffnungen auch im verdrahteten Zustand.

Typ: Wago / 713-126
Geeignet für 10 polige Federleisten mit Leiteranschluss
Steck- und Trennhilfe für Wago Steckverbinder
Zugentlastung der einzelnen verdrahteten Leiter
Einfache Monatage

Betätigungswerkzeug für Wago Steckverbinder

Dient zum Öffnen und Schließen der Klemmkontake an den Wago Steckverbindern.

Typ: Wago Kontakttechnik 734-231

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 „Ethernet/USB Counter Modul mit 8/16 Eingangszählern und 2/4 Ausgangszählern“