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

Beschreibung
Dieser Befehl schließt ein geöffnetes Modul.

Definition
ULONG DapiCloseModule(ULONG handle);

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

Return-Wert
Keiner

Programmierbeispiel

// Modul schließen
DapiCloseModule(handle);

Beschreibung
Dieser Befehl schließt ein geöffnetes Modul.

Definition
ULONG DapiCloseModule(ULONG handle);

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

Return-Wert
Keiner

Programmierbeispiel

// Modul schließen
DapiCloseModule(handle);

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)

Beschreibung
Diese Funktion gibt die Hardwareausstattung (Anzahl der Ein- und
Ausgangskanäle) des Moduls zurück.

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

Parameter
handle=Dies ist der Handle eines offenen Moduls
Abfrage der Anzahl der digitalen Eingangskanäle
par=DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_DI
Abfrage der Anzahl der digitalen Eingangsflipflops
par=DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_DI_FF
Abfrage der Anzahl der digitalen Eingangszähler (16-Bit-Zähler)
par=DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_DI_COUNTER
Abfrage der Anzahl der digitalen Eingangszähler (48-Bit-Zähler)
par=DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_CNT48
Abfrage der Anzahl der digitalen Ausgangskanäle
par=DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_DO
Abfrage der Anzahl der digitalen Impulsgeberausgänge
par=DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_PULSE_GEN
Abfrage der Anzahl der digitalen PWM-Ausgänge
par=DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_PWM_OUT
Abfrage der Anzahl der digitalen Ein-/Ausgangskanäle
par=DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_DX
Abfrage der Anzahl der analogen Eingangskanäle
par=DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_AD
Abfrage der Anzahl der analogen Ausgangskanäle
par=DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_DA
Anzahl der Temperaturkanäle abfragen
par=DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_TEMP
Anzahl der Stepperkanäle abfragen
par=DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_STEPPER

Return value
Abfrage der Anzahl der digitalen Eingangskanäle
return=Anzahl der digitalen Eingangskanäle
Abfrage der Anzahl der digitalen Eingangsflipflops
return=Anzahl der digitalen Eingangsflipflops
Abfrage der Anzahl der digitalen Eingangszähler (16-Bit-Zähler)
return=Anzahl der digitalen Eingangszähler (16-Bit-Zähler)
Abfrage der Anzahl der digitalen Eingangszähler (48-Bit-Zähler)
return=Anzahl der digitalen Eingangszähler (48-Bit-Zähler)
Abfrage der Anzahl der digitalen Ausgangskanäle
return=Anzahl der digitalen Ausgangskanäle
Abfrage der Anzahl der digitalen Impulsgeberausgänge
return=Anzahl der digitalen Impulsgeberausgänge
Abfrage der Anzahl der digitalen PWM-Ausgänge
return=Anzahl der digitalen PWM-Ausgänge
Abfrage der Anzahl der digitalen Eingangs-/Ausgangskanäle
return=Anzahl der digitalen Eingangs-/Ausgangskanäle
Abfrage der Anzahl der analogen Eingangskanäle
return=Anzahl der analogen Eingangskanäle
Abfrage der Anzahl der analogen Ausgangskanäle
return=Anzahl der analogen Ausgangskanäle
Abfrage der Anzahl der Temperaturkanäle
return=Anzahl der Temperaturkanäle
Abfrage der Anzahl der Stepperkanäle
return=Anzahl der Stepperkanäle

Programmierbeispiel

ret=DapiSpecialCommand(handle,
DAPI_SPECIAL_CMD_GET_MODULE_CONFIG,
DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_DI, 0, 0);
//Returns the number of digital input channels
ret=DapiSpecialCommand(handle,
DAPI_SPECIAL_CMD_GET_MODULE_CONFIG,
DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_DO, 0, 0);
//Returns the number of digital output channels
ret=DapiSpecialCommand(handle,
DAPI_SPECIAL_CMD_GET_MODULE_CONFIG,
DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_DX, 0, 0);
//Returns the number of digital input/output channels
ret=DapiSpecialCommand(handle,
DAPI_SPECIAL_CMD_GET_MODULE_CONFIG,
DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_AD, 0, 0);
//Returns the number of analog input channels
ret=DapiSpecialCommand(handle,
DAPI_SPECIAL_CMD_GET_MODULE_CONFIG,
DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_DA, 0, 0);
//Returns the number of analog output channels
ret=DapiSpecialCommand(handle,
DAPI_SPECIAL_CMD_GET_MODULE_CONFIG,
DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_STEPPER, 0, 0);
//Returns the number of stepper channels

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

Beschreibung
Mit dieser Funktion lassen sich alle am USB-Bus angeschlossen Module
scannen.
Hierbei wird die Modul-ID und die Modul-Nr. jedes gefundenen Modules ermittelt.

Definition
ULONG DapiScanAllModulesAvailable(uint nr)

Parameter
nr = 0: Es wird nach allen am USB-Bus angeschlossenen Module gesucht
nr = i: Auslesen der einzelnen angeschlossenen Module

Return-Wert
Gibt die Anzahl der gefunden Module wieder.

Programmierbeispiel

no_of_modules =
DT.Delib.DapiScanAllModulesAvailable(0);
for (i = 1; i <= no_of_modules; i++)
{
ret = DapiScanAllModulesAvailable(i);
moduleID = ret & 0x0000ffff;
moduleNr = (ret >> 16) & 0xff;
}

Beschreibung
Dieser Befehl führt einen direkten Register Schreibbefehl auf das Modul aus.

Definition
void DapiWriteByte(ULONG handle, ULONG adress, ULONG value);

Parameter
handle=Dies ist das Handle eines geöffneten Moduls
adress=Adresse, auf die zugegriffen werden soll
value=Gibt den Datenwert an, der geschrieben wird (8-Bit)

Return-Wert
Keiner

Bemerkung
Dies sollte nur von erfahrenen Programmieren benutzt werden. So kann auf alle zur Verfügung stehenden Register direkt zugegriffen werden.

Programmierbeispiel

// Daten werden in das Register 0x10 geschrieben
DapiWriteByte(handle, 0x10, 0xFF);

Beschreibung
Dieser Befehl führt einen direkten Register Schreibbefehl auf das Modul aus.

Definition
void DapiWriteWord(ULONG handle, ULONG adress, ULONG value);

Parameter
handle=Dies ist das Handle eines geöffneten Moduls
adress=Adresse, auf die zugegriffen werden soll
value=Gibt den Datenwert an, der geschrieben wird (16-Bit)

Return-Wert
Keiner

Bemerkung
Dies sollte nur von erfahrenen Programmieren benutzt werden. So kann auf alle zur Verfügung stehenden Register direkt zugegriffen werden.

Programmierbeispiel

// Daten werden in das Register 0x10 geschrieben
DapiWriteWord(handle, 0x10, 0xFFFF);

Beschreibung
Dieser Befehl führt einen direkten Register Schreibbefehl auf das Modul aus.

Definition
void DapiWriteLong(ULONG handle, ULONG adress, ULONG value);

Parameter
handle=Dies ist das Handle eines geöffneten Moduls
adress=Adresse, auf die zugegriffen werden soll
value=Gibt den Datenwert an, der geschrieben wird (32-Bit)

Return-Wert
Keiner

Bemerkung
Dies sollte nur von erfahrenen Programmieren benutzt werden. So kann auf alle zur Verfügung stehenden Register direkt zugegriffen werden.

Programmierbeispiel

// Daten werden in das Register 0x10 geschrieben
DapiWriteLong(handle, 0x10, 0xFFFFFFFF);

Beschreibung
Dieser Befehl führt einen direkten Register Schreibbefehl auf das Modul aus.

Definition
void DapiWriteLongLong(ULONG handle, ULONG adress, ULONGLONG value);

Parameter
handle=Dies ist das Handle eines geöffneten Moduls
adress=Adresse, auf die zugegriffen werden soll
value=Gibt den Datenwert an, der geschrieben wird (64-Bit)

Return-Wert
Keiner

Bemerkung
Dies sollte nur von erfahrenen Programmieren benutzt werden. So kann auf alle zur Verfügung stehenden Register direkt zugegriffen werden.

Programmierbeispiel

// Daten werden in das Register 0x10 geschrieben
DapiWriteLongLong(handle, 0x10, 0xFFFFFFFFFFFFFFFF);

Beschreibung
Dieser Befehl führt einen direkten Register Lese-Befehl auf das Modul aus.

Definition
ULONG DapiReadByte(ULONG handle, ULONG adress);

Parameter
handle=Dies ist das Handle eines geöffneten Moduls
adress=Adresse, auf die zugegriffen werden soll

Return-Wert
Inhalt des zu lesenden Registers (8-Bit)

Bemerkung
Dies sollte nur von erfahrenen Programmieren benutzt werden. So kann auf alle zur Verfügung stehenden Register direkt zugegriffen werden.

Programmierbeispiel

// Ließt 8 Bit aus der Adresse 0x0
ULONG data;
data = DapiReadByte(handle, 0x0);

Beschreibung
Dieser Befehl führt einen direkten Register Lese-Befehl auf das Modul aus.

Definition
ULONG DapiReadWord(ULONG handle, ULONG adress);

Parameter
handle=Dies ist das Handle eines geöffneten Moduls
adress=Adresse, auf die zugegriffen werden soll

Return-Wert
Inhalt des zu lesenden Registers (16-Bit)

Bemerkung
Dies sollte nur von erfahrenen Programmieren benutzt werden. So kann auf alle zur Verfügung stehenden Register direkt zugegriffen werden.

Programmierbeispiel

// Ließt 16 Bit aus der Adresse 0x0
ULONG data;
data = DapiReadWord(handle, 0x0);

Beschreibung
Dieser Befehl führt einen direkten Register Lese-Befehl auf das Modul aus.

Definition
ULONG DapiReadLong(ULONG handle, ULONG adress);

Parameter
handle=Dies ist das Handle eines geöffneten Moduls
adress=Adresse, auf die zugegriffen werden soll

Return-Wert
Inhalt des zu lesenden Registers (32-Bit)

Bemerkung
Dies sollte nur von erfahrenen Programmieren benutzt werden. So kann auf alle zur Verfügung stehenden Register direkt zugegriffen werden.

Programmierbeispiel

// Ließt 32 Bit aus der Adresse 0x0
ULONG data;
data = DapiReadLong(handle, 0x0);

Beschreibung
Dieser Befehl führt einen direkten Register Lese-Befehl auf das Modul aus.

Definition
ULONGLONG DapiReadLongLong(ULONG handle, ULONG address);

Parameter
handle=Dies ist das Handle eines geöffneten Moduls
address=Adresse, auf die zugegriffen werden soll

Return-Wert
Inhalt des zu lesenden Registers (64-Bit)

Bemerkung
Dies sollte nur von erfahrenen Programmieren benutzt werden. So kann auf alle zur Verfügung stehenden Register direkt zugegriffen werden.

Programmierbeispiel

// Ließt 64 Bit aus der Adresse 0x0
ULONGLONG data;
data = DapiReadLongLong(handle, 0x0);

Beschreibung
Dieser Befehl liest einen einzelnen digitalen Eingang.

Definition
ULONG DapiDIGet1(ULONG handle, ULONG ch);

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

Return-Wert
Zustand des Eingangs (0/1)

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

DAPI_SW_FEATURE_BIT_CFG_DI

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

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

Programmierbeispiel

// 1 Kanal auslesen
unsigned long data;
data = DapiDIGet1(handle, 0);

Beschreibung
Dieser Befehl liest gleichzeitig 8 digitale Eingänge.

Definition
ULONG DapiDIGet8(ULONG handle, ULONG ch);

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

Return-Wert
Zustand der gelesen Eingänge.

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

DAPI_SW_FEATURE_BIT_CFG_DI

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

maxCh = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_GET_MODULE_CONFIG, DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_DI, 0, 0);
maxCh > ch (ch muss sein 0, 8, 16, ...)

Programmierbeispiel

// 8 Kanäle auslesen
unsigned long data;
data = DapiDIGet8(handle, 0);

Beschreibung
Dieser Befehl liest gleichzeitig 16 digitale Eingänge.

Definition
ULONG DapiDIGet16(ULONG handle, ULONG ch);

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

Return-Wert
Zustand der gelesen Eingänge.

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

DAPI_SW_FEATURE_BIT_CFG_DI

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

maxCh = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_GET_MODULE_CONFIG, DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_DI, 0, 0);
maxCh > ch (ch muss sein 0, 16, 32, ...)

Programmierbeispiel

// 16 Kanäle auslesen
unsigned long data;
data = DapiDIGet16(handle, 0);

Beschreibung
Dieser Befehl liest gleichzeitig 32 digitale Eingänge.

Definition
ULONG DapiDIGet32(ULONG handle, ULONG ch);

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

Return-Wert
Zustand der gelesen Eingänge.

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

DAPI_SW_FEATURE_BIT_CFG_DI

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

maxCh = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_GET_MODULE_CONFIG, DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_DI, 0, 0);
maxCh > ch (ch muss sein 0, 32, 64, ...)

Programmierbeispiel

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

Beschreibung
Dieser Befehl liest gleichzeitig 64 digitale Eingänge.

Definition
ULONGLONG DapiDIGet64(ULONG handle, ULONG ch);

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

Return-Wert
Zustand der gelesen Eingänge.

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

DAPI_SW_FEATURE_BIT_CFG_DI

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

maxCh = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_GET_MODULE_CONFIG, DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_DI, 0, 0);
maxCh > ch (ch muss sein 0 oder 64)

Programmierbeispiel

// 64 Kanäle auslesen
ULONGLONG data;
data = DapiDIGet64(handle, 0);

Beschreibung
Dieser Befehl liest die Flip-Flops der Eingänge aus und setzt diese zurück.

Definition
ULONG DapiDIGetFF32(ULONG handle, ULONG ch);

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

Return-Wert
Zustand von 32 Eingangszustandsänderungen.

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

DAPI_SW_FEATURE_BIT_CFG_DI_FF

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

maxCh = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_GET_MODULE_CONFIG, DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_DI_FF, 0, 0);
maxCh > ch (ch muss sein 0, 32, 64, ...)

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

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

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

Return-Wert
Ausgabe des Zählerwertes.

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

DAPI_SW_FEATURE_BIT_CFG_DI_CNT

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

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

Programmierbeispiel

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

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

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

Parameter
handle=Dies ist das Handle eines geöffneten Moduls.
mode=DAPI_SPECIAL_CMD_COUNTER (Es ist ein Counter-Befehl)
mode=DAPI_SPECIAL_COUNTER_LATCH_ALL (Friert alle Zählereingänge ein und stellt diese als Latch bereit)

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

Programmierbeispiel

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

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

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

Parameter
handle=Dies ist das Handle eines geöffneten Moduls.
mode=DAPI_SPECIAL_CMD_COUNTER (Es ist ein Counter-Befehl)
mode=DAPI_SPECIAL_COUNTER_LATCH_ALL_WITH_RESET (Friert alle Zählereingänge ein und stellt diese als Latch bereit und setzt den Zähler der Eingangskanäle zurück)

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

Programmierbeispiel

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

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

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.

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

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.

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

Beschreibung
Diese Funktion liefert den letzten erfassten Fehler eines bestimmten Moduls mithilfe des handles. 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;
}

Beschreibung
Diese Funktion liest den Text des letzten erfassten Fehlers aus. 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;
}

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

Definition
void DapiClearLastError(void);

Parameter
Keine

Return Wert
Keine

Programmierbeispiel

BOOL IsError()
{
unsigned char msg[500];
unsigned long error_code = DapiGetLastError();

if (error_code != DAPI_ERR_NONE)
{
DapiGetLastErrorText((unsigned char*) msg, sizeof(msg));
printf("Error Code = 0x%x * Message = %s\n", error_code, msg);

DapiClearLastError();

return TRUE;
}

return FALSE;
}

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

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

Beschreibung
Dieser Befehl prüft die Verbindung zu einem geöffneten Modul.

Definition
ULONG DapiPing(ULONG handle, ULONG value);

Parameter
handle=Dies ist das Handle eines geöffneten Moduls
value=Übergebener Testwert, im Wertebereich von 0-255 (8-Bit), an das Modul

Return-Wert
Hier muss der mit “value” übergebene Testwert zurückkommen