RO-SER 8/16/32 * Umschalt-Relais (Bistabile-Relais) über ein RS-232/RS-485 – Interface schalten

0 Kundenbewertungen

ab  818,13

 
Zu unseren Vorteilen

 

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-SER-R8-32_UM Kategorie:

Das RO-SER-R8-32_UM Modul ist in Varianten mit 8, 16 oder 32 bistabilen Relais Ausgängen verfügbar. Als Schnittstellen stehen die seriellen Standards RS-232 oder RS-485 zur Auswahl. Zusätzlich kann aber auch der vorhandene USB 2.0 Anschluss genutzt werden.

  • RS-232/RS-485-Interface mit galvanischer Trennung
  • Offenes RS-232/485 Protokoll, Klartextmodus
  • USB 2.0 Interface mit bis zu 480 Mbit
  • 8/16/32 bistabile Wechslerrelais (CO)
  • Relaiskenndaten: 30V DC / 2A DC / 60W DC
  • 2 Leuchtdioden je Relais (Schaltzustände)

Digitale Ausgänge

Bistabile Relais bis 2A

Bei den Relais Ausgängen kommen bistabile Relais mit Wechslerfunktion (CO) zum Einsatz. Sie zeichnen sich dadurch aus, dass das Umschalten nur durch kurze Stromimpulse geschieht. Es muss keine permanente Spulenspannung am Relais anliegen, d.h. auch nach einem Spannungsausfall oder Neustart des Moduls, bleibt das Relais in der letzten Schaltstellung stehen.

 

Fail Safe Modus

Der Fail-Safe-Modus stellt eine Sicherheitsfunktion dar, bei der das DEDITEC Modul, im Falle eines Verbindungsabbruchs, in einen zuvor konfigurierten, sicheren Schaltzustand übergeht.
Dadurch soll verhindert werden, dass angeschlossenen Anlagen oder Systeme unkontrolliert weiter laufen.

 

Für jeden digitalen Ausgang können drei Schaltzustände definiert werden: a) Ausgeschaltet, b) Eingeschaltet oder c) Unverändert.

 

Die Fail-Safe-Schaltung wird durch eine Timeout Schutzfunktion ausgelöst. Erhält die Steuerung innerhalb einer zuvor definierten Zeitspanne keine Befehle mehr seitens des Steuer PCs, tritt die Timeout Funktion in Kraft. Ursache für einen Timeout können sein, Verbindungsabbruch zwischen Steuer PC und der DEDITEC Steuerung oder Ausfall des Steuer PCs.

 

Timeout Modi

Drei Timeout-Modi stehen zur Verfügung:

 

A) Der „Normale Modus“ ist einmal gültig und muss nach jedem Timeout Ereignis manuell per Software Befehl wieder neu aktiviert werden. Die Kunden-Applikation hat weiterhin Zugriff auf alle Ausgänge der Steuerung.

 

B) Beim „Auto reactivate Modus“ wird die Timeout Funktion automatisch wieder aktiviert, nachdem die Kommunikation mit dem Steuer PC wieder hergestellt wurde. Die Kunden-Applikation hat weiterhin Zugriff auf alle Ausgänge der Steuerung.

 

C) Der „Secure outputs Modus“ sperrt den Zugriff auf die Ausgänge nach dem Timeout Ereignis. Ein Entriegeln kann nur per Softwarebefehl erfolgen. Dies ist ein wichtiger Sicherheitsaspekt im Fehlerfall.

 


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.


Allgemein

Spannungsversorgung über externes Netzteil + 12V bis +24V DC (über zweipolige steckbare Schraubklemme)
LEDs • Betriebsspannung
• Interface-Aktivität
• ERROR
• Eingangszustandsänderung (nur bei digitalen Eingängen)
• Timout Abschaltung
• Je zwei LEDs pro Relais Ausgang
Steckverbinder • Typ: Wago Kontakttechnik 713-1108/037-000
• Steckbare 16 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 8 Ausgängen 122mm x 85mm x 51,5mm  (HxBxT)
Abmess. bei 16 Ausgängen 122mm x 126 mm x 51,5 mm (HxBxT)
Abmess. bei 32 Ausgängen 122mm x 208 mm x 51,5 mm (HxBxT)

RS-232 / RS-485 – Interface

Interface • RS-232/RS-485
• Baudrate: 300 – 115.200 Baud
• Galvanische Trennung bis 500 V
• Anschluss über 9 pol. D-Sub Buchse
DIP Schalter • Aktivieren einer Grundkonfiguration (Vorzugsmodus mit 115kBd, Modul Adresse = 0)
• Aktivieren der Konfiguration via DIP-Schalter
• Aktivieren des Text Modus
• Einstellen der Baudrate

USB-Interface
USB-Interface • Anschluss: Typ B
• USB 2.0 / USB 1.1 Interface mit bis zu 480Mbit

Digitale Ausgänge

Timeout-Schutz-Funktion • Einfache und unkomplizierte Einstellung der Timeout-Schutz-Funktion per Software möglich
• Zeitlich festlegbare automatische Aktivierung der Timeout-Schutz-Funktion im
Timeout-Fall (zwischen 0,1 Sekunden und 6553 Sekunden)
• Im Timeout-Fall können digitale Ausgänge aktiviert, deaktiviert oder unverändert gelassen werden
• 3 verschiedene Timeout-Modi: „normal“, „auto reactive“ und „secure outputs“ für verschiedene Vorgehensweisen bei einem Timeout-Fall
Im „secure outputs“ Timeout-Modus wird der Zugriff auf die Ausgänge nach einem Timeout-Fall gesperrt und somit ein weiterer Zugriff auf die Ausgänge verhindert.
Ein Entsperren muss per zusätzlichem Softwarebefehl erfolgen.

Relais Ausgänge Typ V

Relais bis 2A • Typ: TX2L25J
• Eigenschaft: Bistabile Wechsler (CO)
• Max. Schaltspannung: 48V DC
• Max. Schaltstrom: 2 A DC
• Max. Schaltleistung: 60 W
• Galvanische Trennung zw. Kontakt und Spule: 2kV RMS /1 Min
• Mechanische Lebensdauer: bis zu 10 Mio Schaltzyklen

Zusätzliche Informationen

Gewicht n. v.
Anzahl digitaler Ausgänge

, ,

 

 

 

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 der Seriellen-Module

Unsere seriellen Module der RO-Serie und der NET-Serie beherrschen die Standards RS-232 und auch RS-485. Im Auslieferungszustand sind die Module stets für den RS-232 Betrieb ausgelegt, können aber durch Ändern von Jumperpositionen auf dem Modul, auf RS-485 umkonfiguriert werden. Weitere Infos hierzu finden Sie im Handbuch des jeweiligen Produktes.

 


Einstellen der RS-232 / RS-485 Parameter via DIP Schalter

Mit Hilfe von DIP Schaltern lassen sich u.a. folgende Parameter einstellen:

  • Moduladresse (nur bei RS-485)
  • Baudrate
  • Vorzugsmodus (115k Baud, Moduladresse = deaktiviert, Echo = Off)
  • Text Modus / Register Modus

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

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 Ausgabe-Funktionen

DapiDOSet1
Dieser Befehl setzt einen einzelnen Ausgang.

DapiDOSet1

 

Beschreibung

Dieser Befehl setzt einen einzelnen Ausgang.

 

Definition

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

 

Parameter

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

 

Return-Wert

Keiner

 

Anforderungen

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

 

DAPI_SW_FEATURE_BIT_CFG_DO

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

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

DapiDOSet8
Dieser Befehl setzt gleichzeitig 8 digitale Ausgänge.

DapiDOSet8

 

Beschreibung

Dieser Befehl setzt gleichzeitig 8 digitale Ausgänge.

 

Definition

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

 

Parameter

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

 

Return-Wert

Keiner

DapiDOSet16
Dieser Befehl setzt gleichzeitig 16 digitale Ausgänge.

DapiDOSet16

 

Beschreibung

Dieser Befehl setzt gleichzeitig 16 digitale Ausgänge.

 

Definition

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

 

Parameter

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

 

Return-Wert

Keiner

DapiDOSet32
Dieser Befehl setzt gleichzeitig 32 digitale Ausgänge.

DapiDOSet32

 

Beschreibung

Dieser Befehl setzt gleichzeitig 32 digitale Ausgänge.

 

Definition

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

 

Parameter

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

 

Return-Wert

Keiner

 

Programmierbeispiel

// Einen Wert auf die Ausgänge schreiben
data = 0x0000ff00; // Ausgänge 9-16 werden auf 1 gesetzt
DapiDOSet32(handle, 0, data); // Chan Start = 0
printf(„Schreibe auf Ausgänge Daten=0x%x\n“, data);
printf(„Taste für weiter\n“);
getch();
// —————————————————-
// Einen Wert auf die Ausgänge schreiben
data = 0x80000000; // Ausgang 32 wird auf 1 gesetzt
DapiDOSet32(handle, 0, data); // Chan Start = 0
printf(„Schreibe auf Ausgänge Daten=0x%x\n“, data);
printf(„Taste für weiter\n“);
getch();
// —————————————————-
// Einen Wert auf die Ausgänge schreiben
data = 0x80000000; // Ausgang 64 wird auf 1 gesetzt
DapiDOSet32(handle, 32, data); // Chan Start = 32
printf(„Schreibe auf Ausgänge Daten=0x%x\n“, data);
printf(„Taste für weiter\n“);
getch();

DapiDOSet64
Dieser Befehl setzt gleichzeitig 64 digitale Ausgänge.

DapiDOSet64

 

Beschreibung

Dieser Befehl setzt gleichzeitig 64 digitale Ausgänge.

 

Definition

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

 

Parameter

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

 

Return-Wert

Keiner

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

DapiDOClrBit32

 

Beschreibung

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

 

Definition

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

 

Parameter

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

 

Return-Wert

Keiner

 

Bemerkung

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

 

Programmierbeispiel

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

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

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

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

DapiDOSet1_WithTimer
Diese Funktion setzt einen Digitalausgang (ch) auf einen Wert (data - 0 oder 1) für eine bestimmte Zeit in ms.

DapiDOSet1_WithTimer

 

Beschreibung

Diese Funktion setzt einen Digitalausgang (ch) auf einen Wert (data – 0 oder 1) für eine bestimmte Zeit in ms.

 

Definition

void DapiDOSet1_WithTimer(ULONG handle, ULONG ch, ULONG data, ULONG time_ms);

 

Parameter

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

 

Return-Wert

Keiner

 

Bemerkung

Dieser Befehl wird von allen Ausgangsmodulen der NET-Serie, sowie von unserem RO-O8-R8 Modul unterstützt.
Dieser Befehl verliert seine Gültigkeit, sofern er mit anderen Werten überschrieben wird.
Möchte man den Befehl deaktivieren, dann muss er mit time_ms=0 überschrieben werden.

 

Programmierbeispiel

DapiDOSet1_WithTimer(handle, 2, 1, 1000);
//Setting channel 2 for 1000msec to 1

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

DapiDOSetBit32

 

Beschreibung

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

 

Definition

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

 

Parameter

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

 

Return-Wert

Keiner

 

Bemerkung

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

 

Programmierbeispiel

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

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

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

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

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

DapiDOReadback32

 

Beschreibung

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

 

Definition

ULONG DapiDOReadback32(ULONG handle, ULONG ch);

 

Parameter

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

 

Return-Wert

Zustand von 32 Ausgängen.

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

DapiDOReadback32

 

Beschreibung

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

 

Definition

ULONG DapiDOReadback32(ULONG handle, ULONG ch);

 

Parameter

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

 

Return-Wert

Zustand von 32 Ausgängen.

Timeout-Schutz-Funktion

DapiSpecialCommand - DapiSpecialCMDTimeout
Dieser Befehl dient zum Einstellen der Timeout-Schutz-Funktion

DapiSpecialCommand-DapiSpecialCMDTimeout

 

Beschreibung
Dieser Befehl dient zum Einstellen der Timeout-Schutz-Funktion.

Es gibt seit 2021 drei unterschiedliche Timeout-Methoden.

 

„normalen“ Timeout
Dies ist der Timeout, den unsere Module schon seit 2009 besitzen.
Vorgehensweise für den Timeout-Befehl:
Der Timeout wird per Befehl aktiviert.
Findet dann ein sogenanntes Timeout-Ereignis statt(Pause zwischen zwei Zugriffen auf das Modul ist grösser, als die erlaubte Timeout-Zeit) passiert folgendes:
– Alle Ausgänge werden ausgeschaltet.
– Der Timeout-Status geht auf „2“.
– Die Timeout-LED geht an (bei Modulen, die solch einen Status haben)
Weitere Zugriffe auf die Ausgänge sind dann weiterhin möglich, aber der Timeout ist nicht weiter aktiv. Erst wieder, wenn er wieder aktiviert wurde.

 

„auto reactivate“ Timeout
Dies ist ein seit 2021 implementierter Timeout-Modus, der nach Auftreten des Timeout-Ereignisses den Timeout automatisch wieder aktiviert.
Vorgehensweise für den Timeout-Befehl:
Der Timeout wird per Befehl aktiviert.
Findet dann ein sogenanntes Timeout-Ereignis statt(Pause zwischen zwei Zugriffen auf das Modul ist grösser, als die erlaubte Timeout-Zeit) passiert folgendes:
– Alle Ausgänge werden ausgeschaltet.
– Der Timeout-Status geht auf „4“.
– Die Timeout-LED geht an (bei Modulen, die solch einen Status haben)
Weitere Zugriffe auf die Ausgänge sind dann weiterhin möglich. UND der Timeout ist weiter aktiv. Bei erneuter Zeitüberschreitung der Timeout-Zeit werden die Ausgänge wieder ausgeschaltet.

 

„secure outputs“ Timeout
Dies ist ein seit 2021 implementierter Timeout-Modus, der nach Auftreten des Timeout-Ereignisses einen Schreibenden Zugriff auf die Ausgänge verhindert.Somit wird sichergestellt, dass die Software erst einmal einen „sicheren“ Zustand der Ausgänge wiederherstellen muss, da der Timeout-Mechanismus des Moduls die Ausgänge auf vordefinierte Werte verändert hat.
Vorgehensweise für den Timeout-Befehl:
Der Timeout wird per Befehl aktiviert.
Findet dann ein sogenanntes Timeout-Ereignis statt(Pause zwischen zwei Zugriffen auf das Modul ist grösser, als die erlaubte Timeout-Zeit) passiert folgendes:
– Alle Ausgänge werden ausgeschaltet.
– Der Timeout-Status geht auf „6“.
– Die Timeout-LED geht an (bei Modulen, die solch einen Status haben)
Weitere Zugriffe auf die Ausgänge sind NICHT möglich. Erst nach erneutem Aktivieren des Timeouts oder Deaktivieren des Timeouts können die Ausgänge beschrieben werden.

 

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

 

Parameter
handle = Dies ist das Handle eines geöffneten Moduls
cmd = auszuführende Funktion
par1 = Wert, der an die Funktion übergeben wird
par2 = Wert, der an die Funktion übergeben wird

DapiSpecialCommand - DapiSpecialTimeoutSetValueSec
Dieser Befehl dient zum Setzen der Timeout-Zeit

DapiSpecialCommand – DapiSpecialTimeoutSetValueSec

 

Beschreibung
Dieser Befehl dient zum Setzen der Timeout-Zeit.

 

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

 

Parameter
cmd = DAPI_SPECIAL_TIMEOUT_SET_VALUE_SEC
par1 = Sekunden [s]
par2 = Millisekunden [100ms] (Wert 6 = 600ms)

 

Bemerkung

Der zulässige Wertebereich der Zeitangabe liegt zwischen 0,1 Sekunden und 6553 Sekunden

 

Programmierbeispiel

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT,
DAPI_SPECIAL_TIMEOUT_SET_VALUE_SEC, 3, 7);
//Die Zeit des Timeouts wird auf 3,7sek gesetzt.

DapiSpecialCommand - DapiSpecialTimeoutActivate
Dieser Befehl aktiviert den "normalen" Timeout

DapiSpecialCommand – DapiSpecialTimeoutActivate

 

Beschreibung

Dieser Befehl aktiviert den „normalen“ Timeout.
Nach dem Timeout-Ereignis werden..
– ..alle Ausgänge ausgeschaltet
– ..der Timeout-Status auf „2“ gesetzt
– ..die Timeout-LED angeschaltet (bei Modulen, die solch einen Status haben)
Weitere Zugriffe auf die Ausgänge sind dann weiterhin möglich, aber der Timeout ist nicht weiter aktiv.
Erst wieder, wenn er wieder aktiviert wurde.

 

Definition

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT, cmd, 0, 0);

 

Parameter
cmd = DAPI_SPECIAL_TIMEOUT_ACTIVATE

 

Programmierbeispiel

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT,
DAPI_SPECIAL_TIMEOUT_ACTIVATE, 0, 0);
//Der „normale“ Timeout wird aktiviert.

DapiSpecialCommand - DapiSpecialTimeoutActivateAutoReactivate
Dieser Befehl aktiviert den "auto reactivate" Timeout

DapiSpecialCommand – DapiSpecialTimeoutActivateAutoReactivate

 

Beschreibung

Dieser Befehl aktiviert den „auto reactivate“ Timeout.
In diesem Modus wird der Timeout nach dem Timeout-Ereignis automatisch wieder aktiviert.
Nach dem Timeout-Ereignis werden..
– ..alle Ausgänge ausgeschaltet
– ..der Timeout-Status auf „4“ gesetzt
– ..die Timeout-LED angeschaltet (bei Modulen, die solch einen Status haben)
Weitere Zugriffe auf die Ausgänge sind dann weiterhin möglich UND der Timeout ist weiter aktiv.
Bei erneuter Zeitüberschreitung der Timeout-Zeit werden die Ausgänge weider ausgeschaltet.

 

Definition

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT, cmd, 0, 0);

 

Parameter
cmd = DAPI_SPECIAL_TIMEOUT_ACTIVATE_AUTO_REACTIVATE

 

Programmierbeispiel

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT,
DAPI_SPECIAL_TIMEOUT_ACTIVATE_AUTO_REACTIVATE, 0, 0);
//Der „auto reactivate“ Timeout wird aktiviert.

DapiSpecialCommand - DapiSpecialTimeoutActivateSecureOutputs
Dieser Befehl aktiviert den "secure outputs" Timeout

DapiSpecialCommand – DapiSpecialTimeoutActivateSecureOutputs

 

Beschreibung

Dieser Befehl aktiviert den „secure outputs“ Timeout.
In diesem Modus wird ein schreibender Zugriff auf die Ausgänge nach einem Timeout-Ereignis verhindert.
Somit wird sichergestellt, dass die Software erst einmal einen „sicheren“ Zustand der Ausgänge wiederherstellen muss,
da der Timeout-Mechanismus des Moduls die Ausgänge auf vordefinierte Werte verändert hat.
Nach dem Timeout-Ereignis werden..
– ..alle Ausgänge ausgeschaltet
– ..der Timeout-Status auf „6“ gesetzt
– ..die Timeout-LED angeschaltet (bei Modulen, die solch einen Status haben)
Weitere Zugriffe auf die Ausgänge sind NICHT möglich. Erst nach erneutem Aktivieren des
Timeouts oder Deaktivieren des Timeouts können die Ausgänge beschrieben werden.

 

Definition

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT, cmd, 0, 0);

 

Parameter
cmd = DAPI_SPECIAL_TIMEOUT_ACTIVATE_SECURE_OUTPUTS

 

Programmierbeispiel

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT,
DAPI_SPECIAL_TIMEOUT_ACTIVATE_SECURE_OUTPUTS, 0, 0);
//Der „secure outputs“ Timeout wird aktiviert.

DapiSpecialCommand - DapiSpecialTimeoutDeactivate
Dieser Befehl deaktiviert den Timeout

DapiSpecialCommand – DapiSpecialTimeoutDeactivate

 

Beschreibung

Dieser Befehl deaktiviert den Timeout.

 

Definition

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT, cmd, 0, 0);

 

Parameter

cmd = DAPI_SPECIAL_TIMEOUT_DEACTIVATE

 

Programmierbeispiel

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT,
DAPI_SPECIAL_TIMEOUT_DEACTIVATE, 0, 0);
//Der Timeout wird deaktiviert.

DapiSpecialCommand - DapiSpecialTimeoutGetStatus
Dieser Befehl dient zum Auslesen des Timeout-Status

DapiSpecialCommand – DapiSpecialTimeoutGetStatus

 

Beschreibung

Dieser Befehl dient zum Auslesen des Timeout-Status.

 

Definition

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

 

Parameter

cmd = DAPI_SPECIAL_TIMEOUT_GET_STATUS

 

Return-Wert

Return = 0 (Timeout ist deaktiviert)

 

Werte für den „normalen“ Timeout
Return = 1 (Timeout „normal“ ist aktiviert)
Return = 2 (Timeout „normal“ hat stattgefunden)

 

Werte für den „auto reactivate“ Timeout
Return = 3 (Timeout „auto reactivate“ ist aktiviert)
Return = 4 (Timeout „auto reactivate“ hat ein oder mehrmals stattgefunden)

 

Werte für den „secure“ Timeout
Return = 5 (Timeout „secure“ ist aktiviert)
Return = 6 (Timout „secure“ hat stattgefunden. In diesem Status wird ein Schreiben auf die Outputs verhindert)

 

Programmierbeispiel

unsigned long status = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT,
DAPI_SPECIAL_TIMEOUT_GET_STATUS, 0, 0);
printf(„Status = %ul\n“, status);
//Abfrage des Timeout-Status mit Ausgabe.

DapiSpecialCommand - DapiSpecialTimeoutDoValueMaskWRSet32
Dieser Befehl aktiviert Relais bei einem Timeout

DapiSpecialCommand – DapiSpecialTimeoutDoValueMaskWRSet32

 

Beschreibung

Dieser Befehl bestimmt die Ausgänge, die bei einem Timeout gesetzt werden sollen.

 

Definition

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT, cmd, ch, par2);

 

Parameter

cmd = DAPI_SPECIAL_TIMEOUT_DO_VALUE_MASK_WR_SET32
ch = Gibt die Nummer des Ausgangs an, ab dem geschrieben werden soll (0, 32, 64, ..)
par2 = [32 Bit] Gibt die Ausgänge an, welche bei einem Timeout aktiviert werden sollen

 

Programmierbeispiel

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT,
DAPI_SPECIAL_TIMEOUT_DO_VALUE_MASK_WR_SET32, 0, 0xff);
//Die ersten 8 Relais werden im Timeout Fall eingeschaltet.

DapiSpecialCommand - DapiSpecialTimeoutDoValueMaskRDSet32
Dieser Befehl dient zum Auslesen der übergebenen Werte

DapiSpecialCommand – DapiSpecialTimeoutDoValueMaskRDSet32

 

Beschreibung

Dieser Befehl dient zum Auslesen der übergebenen Werte

 

Definition

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

 

Parameter

cmd = DAPI_SPECIAL_TIMEOUT_DO_VALUE_MASK_RD_SET32

 

Return-Wert

[32 Bit] Wert der dem SET-Befehl übergeben wird

 

Programmierbeispiel

unsigned long value = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT,
DAPI_SPECIAL_TIMEOUT_DO_VALUE_MASK_RD_SET32, 0, 0);
printf(„%0x\n“, value);
//Der Wert der dem SET-Befehl übergeben wurde, wird ausgelesen und dargestellt.

DapiSpecialCommand - DapiSpecialTimeoutDoValueMaskWRClr32
Dieser Befehl deaktiviert Relais bei einem Timeout

DapiSpecialCommand – DapiSpecialTimeoutDoValueMaskWRClr32

 

Beschreibung

Dieser Befehl bestimmt die Ausgänge, die bei einem Timeout ausgeschaltet werden sollen.

 

Definition

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT, cmd, ch, par2);

 

Parameter

cmd = DAPI_SPECIAL_TIMEOUT_DO_VALUE_MASK_WR_CLR32
ch = Gibt die Nummer des Ausgangs an, ab dem geschrieben werden soll (0, 32, 64, ..)
par2 = [32 Bit] Gibt die Ausgänge an, welche bei einem Timeout deaktiviert werden sollen

 

Programmierbeispiel

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT,
DAPI_SPECIAL_TIMEOUT_DO_VALUE_MASK_WR_CLR32, 0, 0xff);
//Die ersten 8 Relais werden im Timeout Fall ausgeschaltet.

DapiSpecialCommand - DapiSpecialTimeoutDoValueMaskRDClr32
Dieser Befehl dient zum Auslesen der übergebenen Werte

DapiSpecialCommand – DapiSpecialTimeoutDoValueMaskRDClr32

 

Beschreibung

Dieser Befehl dient zum Auslesen der übergebenen Werte.

 

Definition

LONG DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT, cmd, 0, 0);

 

Parameter

cmd = DAPI_SPECIAL_TIMEOUT_DO_VALUE_MASK_RD_CLR32

 

Return-Wert

[32 Bit] Wert der dem CLR-Befehl übergeben wird

 

Programmierbeispiel

unsigned long value = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT,
DAPI_SPECIAL_TIMEOUT_DO_VALUE_MASK_RD_CLR32, 0, 0);
printf(„%0x\n“, value);
//Der Wert der dem CLR-Befehl übergeben wurde, wird ausgelesen und dargestellt.

DapiSpecialCommand - DapiSpecialTimeoutDoValueLoadDefault
Setzt die SET- und CLR-Werte auf den Ursprungswert zurück

DapiSpecialCommand – DapiSpecialTimeoutDoValueLoadDefault

 

Beschreibung

Setzt die SET- und CLR-Werte auf den Default-Wert zurück.
(SET-Wert = 0, CLR-Wert = FFFFFFFF)

 

Definition

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT, cmd, 0, 0);

 

Parameter

cmd = DAPI_SPECIAL_TIMEOUT_DO_VALUE_LOAD_DEFAULT

 

Programmierbeispiel

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT,
DAPI_SPECIAL_TIMEOUT_DO_VALUE_LOAD_DEFAULT, 0, 0);
//SET- und CRL-Werte werden auf den Default-Wert gesetzt.

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

Blockschaltbild RO-R8_UM

 

Anschlussbeispiel RO-R8_UM

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

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

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²

16 poliger Steckverbinder

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

  • Typ: Wago Kontakttechnik 713-1108/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

DSUB-9 Verlängerungskabel 1,8m

DSUB-9 Verlängerungskabel. Buchse auf Stecker. 1,8 Meter

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)

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

Das MOD-REL8_10A verfügt über acht Umschaltrelais mit einer Schaltleistung von 48V/10A AC oder 30V/8A DC. Es kann als zusätzliche Leistungsstufe für unsere digitalen Ausgangs Module verwendet werden. Die Schließerkontakte eines digitalen Ausgangsmoduls, z.B. eines RO-USB-REL16, werden einfach parallel auf die Eingänge dieser Leistungsstufe geklemmt. Zusätzlich benötigt dieses Modul eine Spannungsversorgung von 24V DC.

  • Leistungsstufe für alle digitalen Ausgangsmodule
  • 8 Wechsler Relais (CO) / 48V / 10A AC bzw. 30V / 8A DC
  • 24V Spannungsversorgung
  • Steckbare Klemmleisten für die Anschlussverdrahtung
  • Potentialfreie Eingänge (keine Steuerspannung nötig)

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

12V 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 / 220V DC
  • Schaltspannung: 250 V AC/DC
  • 1 Wechsler
  • Verpolschutz, Freilaufdiode
  • LED für Spannungsanzeige
  • Phoenix Contact, 2967617, PLC-RSC- 12DC/21HC

24V 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: 24V AC/DC
  • Schaltspannung: 250 V AC/DC
  • 1 Wechsler
  • Verpolschutz, Freilaufdiode
  • LED für Spannungsanzeige
  • Phoenix Contact, 2967633, PLC-RSC- 24UC/21HC

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²

16 poliger Steckverbinder

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

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

Zugentlastungsplatte für 16 oder 18 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-127
  • Geeignet für 16 oder 18 polige Federleisten mit Leiteranschluss
  • Steck- und Trennhilfe für Wago Steckverbinder
  • Zugentlastung der einzelnen verdrahteten Leiter
  • Einfach 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 „RO-SER 8/16/32 * Umschalt-Relais (Bistabile-Relais) über ein RS-232/RS-485 – Interface schalten“

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