USB analog converter * 16-Bit D/A Wandler – 4/8 Kanäle

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 setzt den Modus für einen D/A-Wandler.

Definition
void DapiDASetMode(ULONG handle, ULONG ch, ULONG mode);

Parameter
handle=Dies ist das Handle eines geöffneten Moduls
ch=Gibt den Kanal des D/A-Wandlers an (0 .. )
mode=Gibt den Modus für den D/A-Wandler an

Return-Wert
Keiner

Bemerkung
Folgende Modi werden unterstützt:
(diese sind abhängig von dem verwendeten D/A-Modul)

Unipolare Spannungen
ADDA_MODE_UNIPOL_10V
ADDA_MODE_UNIPOL_5V
ADDA_MODE_UNIPOL_2V5

Bipolare Spannungen
ADDA_MODE_BIPOL_10V
ADDA_MODE_BIPOL_5V
ADDA_MODE_BIPOL_2V5

Ströme
ADDA_MODE_0_20mA
ADDA_MODE_4_20mA
ADDA_MODE_0_24mA
ADDA_MODE_0_25mA
ADDA_MODE_0_50mA

Programmierbeispiel

// Setzt Kanal 0 auf den Modus 0 .. 10V
DapiDASetMode(handle, 0,  DAPI_ADDA_MODE_16BIT_UNIPOL_10V);

Beschreibung
Dieser Befehl liest den eingestellten Modus eines D/A-Wandlers zurück.

Definition
ULONG DapiDAGetMode(ULONG handle, ULONG ch);

Parameter
handle=Dies ist das Handle eines geöffneten Moduls
ch=Gibt den Kanal des D/A-Wandlers an (0 .. )

Return-Wert
Modus des D/A-Wandlers

Programmierbeispiel

// Ließt den aktuellen Modus von Kanal 1 zurück
unsigned long mode;
mode = DapiDAGetMode(handle, 0);
// Modus überprüfen
if(mode == DAPI_ADDA_MODE_16BIT_UNIPOL_10V)
{
printf("Modus ist 0 .. 10V");
}

Beschreibung
Dieser Befehl übergibt ein Datenwert an einen Kanal eines D/A-Wandlers.

Definition
void DapiDASet(ULONG handle, ULONG ch, ULONG data);

Parameter
handle=Dies ist das Handle eines geöffneten Moduls
ch=Gibt den Kanal des D/A-Wandlers an (0 .. )
data=Gibt den Datenwert an, der geschrieben wird
(16-Bit Datenwert -> Datenwertebereich: 0-65535)

Return-Wert
Keiner

Programmierbeispiel

DapiDASet(handle, 0, 65535);
// Setzt den 1. Ausgang des D/A-Wandlers auf maximalen Wert des
gewählten Modus.
//(bei ausgewähltem Modus ADDA_MODE_UNIPOL_10V wird der 1. Ausgang
des D/A-Wandlers auf 10V gesetzt)

Beschreibung
Dieser Befehl setzt eine Spannung an einen Kanal eines D/A-Wandlers.

Definition
void DapiDASetVolt(ULONG handle, ULONG ch, float data);

Parameter
handle=Dies ist das Handle eines geöffneten Moduls
ch=Gibt den Kanal des D/A-Wandlers an (0 .. )
data=Gibt die Spannung an, die eingestellt werden soll [V]

Return-Wert
Keiner

Programmierbeispiel

DapiDASetVolt(handle, 0, 5,4321);
// Setzt den 1. Ausgang des D/A-Wandlers auf 5,4321 V

Beschreibung
Dieser Befehl setzt einen Strom an einen Kanal eines D/A-Wandlers.

Definition
void DapiDASetmA(ULONG handle, ULONG ch, float data);

Parameter
handle=Dies ist das Handle eines geöffneten Moduls
ch=Gibt den Kanal des D/A-Wandlers an (0 .. )
data=Gibt den Strom an, der geschrieben wird [mA]

Return-Wert
Keiner

Bemerkung
Dieser Befehl ist modulabhängig. Er funktioniert natürlich nur, wenn das Modul auch den Strom-Modus unterstützt.

Beschreibung
Dieser Befehl setzt die Spannungswerte bei einem Kanal beim Einschalten bzw. nach einem Timeout eines D/A-Wandlers (EEPROM-Konfiguration).

Definition
void DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_DA, cmd, ch, 0);

Parameter
handle=Dies ist das Handle eines geöffneten Moduls
ch=Gibt den Kanal des D/A-Wandlers an (0, 1, 2, ..)
Zurücksetzen der Einstellungen auf Default Konfiguration
cmd=DAPI_SPECIAL_DA_PAR_DA_LOAD_DEFAULT
Speichern der Konfiguration in das EEPROM
cmd=DAPI_SPECIAL_DA_PAR_DA_SAVE_EEPROM_CONFIG
Laden der Konfiguration aus dem EEPROM
cmd=DAPI_SPECIAL_DA_PAR_DA_LOAD_EEPROM_CONFIG

Return-Wert
Keiner

Bemerkung
DAPI_SPECIAL_CMD_DA_PAR_DA_LOAD_DEFAULT
Mit diesem Befehl wird die Default Konfiguration eines D/A-Wandlers geladen.
Der D/A-Wandler hat jetzt als Ausgabespannung 0V.

DAPI_SPECIAL_DA_PAR_DA_SAVE_EEPROM_CONFIG
Mit diesem Befehl wird die aktuelle D/A-Wandler Einstellung (Spannung/Strom-Wert, Enable/Disable und D/A-Wandler Modus) in das EEPROM gespeichert.

DAPI_SPECIAL_DA_PAR_DA_LOAD_EEPROM_CONFIG
Mit diesem Befehl wird der D/A-Wandler, mit der im EEPROM gespeicherten Konfiguration, gesetzt.

Programmierbeispiel

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_DA, DAPI_SPECIAL_DA_PAR_DA_LOAD_DEFAULT, 1, 0);
//Zurücksetzen der EEPROM-Konfiguration auf Default Konfiguration bei Kanal 1.
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_DA, DAPI_SPECIAL_DA_PAR_DA_SAVE_EEPROM_CONFIG, 3, 0);
//Speichern der D/A-Wandler Einstellungen in das EEPROM bei Kanal 3.
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_DA, DAPI_SPECIAL_DA_PAR_DA_LOAD_EEPROM_CONFIG, 2, 0);
//Setzen des D/A-Wandlers, mit der im EEPROM gespeicherten Konfiguration bei Kanal 2.

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

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.

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.

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.

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.

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.

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.

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