ULONG DapiOpenModule(ULONG moduleID, ULONG nr);
Diese Funktion öffnet ein bestimmtes Modul

ULONG DapiCloseModule(ULONG handle);
Dieser Befehl schliesst ein geöffnetes Modul.

ULONG DapiGetLastError();
Diese Funktion liefert den letzten erfassten Fehler.

ULONG DapiGetLastErrorText(unsigned char * msg, unsigned long msg_length);
Diese Funktion liest den Text des letzten erfassten Fehlers.

ULONG DapiGetDELIBVersion(ULONG mode, ULONG par);
Diese Funktion gibt die installierte DELIB-Version zurück.

ULONG DapiSpecialCommand(ULONG handle, DAPI_SPECIAL_CMD_GET_MODULE_CONFIG, par, 0, 0);
Diese Funktion gibt die Hardwareaustattung (Anzahl der Ein- bzw. Ausgangskanäle) des Moduls zurück.

ULONG DapiOpenModuleEx(ULONG moduleID, ULONG nr, unsigned char* exbuffer);
Diese Funktion öffnet ein bestimmtes RO-ETH-Modul. Besonderheit hierbei ist, dass Parameter wie IP-Adresse und Portnummer direkt mit angegeben werden.

ULONG DapiDIGet1(ULONG handle, ULONG ch);
Dieser Befehl liest einen einzelnen digitalen Eingang.

ULONG DapiDIGet8(ULONG handle, ULONG ch);
Dieser Befehl liest gleichzeitig 8 digitale Eingänge.

ULONG DapiDIGet16(ULONG handle, ULONG ch);
Dieser Befehl liest gleichzeitig 16 digitale Eingänge.

ULONG DapiDIGet32(ULONG handle, ULONG ch);
Dieser Befehl liest gleichzeitig 32 digitale Eingänge.

ULONGLONG DapiDIGet64(ULONG handle, ULONG ch);
Dieser Befehl liest gleichzeitig 64 digitale Eingänge.

ULONG DapiDIGetFF32(ULONG handle, ULONG ch);
Dieser Befehl liest die Flip-Flops der Eingänge aus und setzt diese zurück. (Eingangszustands-Änderung)

ULONG DapiDIGetCounter(ULONG handle, ULONG ch, ULONG mode);
Dieser Befehl liest den Eingangszähler eines digitalen Eingangs.

void DapiSpecialCommand(ULONG handle, DAPI_SPECIAL_CMD_COUNTER, DAPI_SPECIAL_COUNTER_LATCH_ALL, 0, 0);
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.

void DapiSpecialCommand(ULONG handle, DAPI_SPECIAL_CMD_COUNTER, DAPI_SPECIAL_COUNTER_LATCH_ALL_WITH_RESET, 0, 0);
Dieser Befehl speichert die Zählerstände aller Eingangszähler gleichzeitig in ein Zwischenspeicher (Latch). Zusätzlich werden die Zählerstände der Eingangszähler im Anschluß resettet.

void DapiDOSet1(ULONG handle, ULONG ch, ULONG data);
Dieser Befehl setzt einen einzelnen Ausgang.

void DapiDOSet8(ULONG handle, ULONG ch, ULONG data);
Dieser Befehl setzt gleichzeitig 8 digitale Ausgänge.

void DapiDOSet16(ULONG handle, ULONG ch, ULONG data);
Dieser Befehl setzt gleichzeitig 16 digitale Ausgänge.

void DapiDOSet32(ULONG handle, ULONG ch, ULONG data);
Dieser Befehl setzt gleichzeitig 32 digitale Ausgänge.

void DapiDOSet64(ULONG handle, ULONG ch, ULONGLONG data);
Dieser Befehl setzt gleichzeitig 64 digitale Ausgänge.

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

ULONG DapiDOReadback32(ULONG handle, ULONG ch);
Dieser Befehl liest die 32 digitalen Ausgänge zurück.

ULONGLONG DapiDOReadback64(ULONG handle, ULONG ch);
Dieser Befehl liest die 64 digitalen Ausgänge zurück.

void DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT, cmd, par1, par2);
Dieser Befehl dient zum Setzen der Timeout-Zeit.

ULONG DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT, DAPI_SPECIAL_TIMEOUT_GET_STATUS, 0, 0);
Dieser Befehl dient zum Auslesen des Timeout-Status.

void DapiADSetMode(ULONG handle, ULONG ch, ULONG mode);
Dieser Befehl konfiguriert den Spannungsbereich für einen A/D Wandler.

ULONG DapiADGetMode(ULONG handle, ULONG ch);
Dieser Befehl liest den eingestellten Modus eines A/D Wandlers zurück. Modus-Beschreibung siehe DapiADSetMode.

ULONG DapiADGet(ULONG handle, ULONG ch);
Dieser Befehl liest einen Datenwert von einen Kanal eines A/D Wandlers.

float DapiADGetVolt(ULONG handle, ULONG ch);
Dieser Befehl liest einen Datenwert von einen Kanal eines A/D Wandlers in Volt.

float DapiADGetmA(ULONG handle, ULONG ch);
Dieser Befehl liest einen Datenwert von einen Kanal eines A/D Wandlers in mA.

float DapiTempGet(ULONG handle, ULONG ch);
Dieser Befehl liest einen Temperatur Kanal.

void DapiDASetMode(ULONG handle, ULONG ch, ULONG mode);
Dieser Befehl setzt den Modus für einen D/A Wandler.

ULONG DapiDAGetMode(ULONG handle, ULONG ch);
Dieser Befehl liest den eingestellten Modus eines D/A Wandlers zurück.

void DapiDASet(ULONG handle, ULONG ch, ULONG data);
Dieser Befehl übergibt ein Datenwert an einen Kanal eines D/A Wandlers.

void DapiDASetVolt(ULONG handle, ULONG ch, float data);
Dieser Befehl setzt eine Spannung an einen Kanal eines D/A Wandlers.

void DapiDASetmA(ULONG handle, ULONG ch, float data);
Dieser Befehl setzt einen Strom an einen Kanal eines D/A Wandlers.

void DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_DA, cmd, ch, 0);
Dieser Befehl setzt die Spannungswerte bei einem Kanal beim Einschalten bzw. nach einem Timeout eines D/A Wandlers (EEPROM-Konfiguration).

void DapiSpecialCommand(ULONG handle, DAPI_SPECIAL_CMD_AD, DAPI_SPECIAL_AD_READ_MULTIPLE_AD, ULONG start_ch, ULONG end_ch);
Dieser Befehl speichert die Werte bestimmer, benachbarter Kanäle eines A/D Wandlers gleichzeitig in einen Zwischenpuffer. So können anschließend die Werte nacheinander ausgelesen werden. Vorteil hierbei ist, dass die A/D-Werte zum einen gleichzeitig gepuffert werden, zum anderen können die Werte (im Vergleich zum Befehl DapiADGet) anschließend schneller abgefragt werden.

void DapiCnt48ModeSet(ULONG handle, ULONG ch, ULONG mode);
Dieser Befehl setzt einen Zählmodus (optional auch Submodus) und Eingangsfilter für einen bestimmten Eingangszählerkanal.

ULONG DapiCnt48ModeGet(ULONG handle, ULONG ch);
Dieser Befehl liest den Zählmodus eines bestimmten Eingangszählerkanals zurück.

ULONG DapiCnt48CounterGet32(ULONG handle, ULONG ch);
Dieser Befehl liest die ersten 32 Bit eines 48 Bit Eingangszählers.

ULONGLONG DapiCnt48CounterGet48(ULONG handle, ULONG ch);
Dieser Befehl liest einen 48 Bit Zähler eines Eingangszählerkanals.

void DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_DI, DAPI_SPECIAL_DI_FF_FILTER_VALUE_SET, ULONG time_ms, 0);
Dieser Befehl setzt einen Filter [ms], in welchem Zeitintervall digitale Eingangskanäle abgetastet werden.

ULONG DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_DI, DAPI_SPECIAL_DI_FF_FILTER_VALUE_GET, 0, 0);
Dieser Befehl gibt den Filter [ms] zurück, in welchem Zeitintervall digitale Eingangskanäle abgetastet werden.

void DapiPulseGenSet(ULONG handle, ULONG ch, ULONG mode, ULONG par0, ULONG par1, ULONG par2);
Dieser Befehl generiert eine gewisse Anzahl an Impulsen mit vorgegebenen low- und high-Zeiten.

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

void DapiSpecialCommand(ULONG handle, DAPI_SPECIAL_CMD_CNT48, DAPI_SPECIAL_CNT48_RESET_GROUP8, ULONG ch, 0)
Dieser Befehl resettet gleichzeitig die Zählerstände von 8 Eingangszählern.

void DapiSpecialCommand(ULONG handle, DAPI_SPECIAL_CMD_CNT48, DAPI_SPECIAL_CNT48_RESET_SINGLE, ULONG ch, 0)
Dieser Befehl resettet den Zählerstand eines einzelnen Eingangszählers.

ULONG DapiSpecialCommand(ULONG handle, DAPI_SPECIAL_CMD_CNT48, DAPI_SPECIAL_CNT48_DI_GET1, ULONG ch, 0);
Dieser Befehl liest den Eingangszustand (0/1) eines digitalen Eingangszählerkanals.

void DapiSpecialCommand(ULONG handle, DAPI_SPECIAL_CMD_SET_DIR_DX_1, ULONG ch, ULONG dir, 0);
Dieser Befehl setzt die Richtung von TTL-Ein/Ausgängen (1-Bit weise)

void DapiSpecialCommand(ULONG handle, DAPI_SPECIAL_CMD_SET_DIR_DX_8, ULONG ch, ULONG dir, 0);
Dieser Befehl setzt die Richtung von TTL-Ein/Ausgängen (8-Bit weise)

void DapiWatchdogEnable(ULONG handle);
Diese Funktion aktiviert den Watchdog.

void DapiWatchdogDisable(ULONG handle);
Diese Funktion deaktiviert den Watchdog.

void DapiWatchdogRetrigger(ULONG handle);
Diese Funktion retriggert den Watchdog-Timer.

ULONG DapiSpecialCommand(ULONG handle, DAPI_SPECIAL_CMD_WATCHDOG, cmd, par1, 0);
Diese Funktion gibt verschiedene Status Informationen des Watchdog-Sticks zurück oder setzt diese.

ULONG DapiStepperCommandEx(ULONG handle, ULONG motor, ULONG cmd, ULONG par1, ULONG par2, ULONG par3, ULONG par4, ULONG par5, ULONG par6, ULONG par7);
Dieser erweiterte Befehl steuert Schrittmotoren an.

DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_STOP, 0, 0, 0, 0);
Dieses Kommando dient zum Anhalten des Motors, die Bremsrampe wird dabei eingehalten.

DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_GO_POSITION, position, 0, 0, 0);
Hiermit wird eine bestimmte Position angefahren. Dieses Kommando darf nur ausgeführt werden, wen der Motor nicht disable ist und kein Go_Position oder Go_Referenz ausgeführt wird.

void DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_GO_POSITION_RELATIVE, go_pos_rel_par, 0, 0, 0);
Hiermit wird eine relative Position angefahren. Im Gegensatz zum Befehl GO_POSITION, der eine absolute Position anfährt, wird hier die momentane Position berücksichtigt. Dieses Kommando darf nur ausgeführt werden, wenn der Motor nicht "disabled" ist und kein Go_Position oder Go_Referenz ausgeführt wird.

DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_GO_REFSWITCH, par1, par2, par3, 0);
Der Motor fährt zur Referenzposition

DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_FULLSTOP, 0, 0, 0, 0);
Dieses Kommando dient zum sofortigen Anhalten des Motors, die Bremsrampe wird dabei nicht eingehalten. Die Motorposition kann vielleicht danach nicht mehr stimmen, da der Motor unkontrolliert angehalten wird.

DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_DISABLE, par1, 0, 0, 0);
Dieses Kommando dient zum disablen/enabeln des Motors, der Motor verfährt dann nicht mehr/oder wieder. Dieses Kommando darf nur bei Motorstillstand benutzt werden.

DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_SET_POSITION, par1, 0, 0, 0);
Dieses Kommando dient zum setzen der Motorposition. Die Auflösung beträgt 1/16 Vollschritt. Dieses Kommando darf nur bei angehaltenem Motor verwendet werden.

DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_SET_FREQUENCY, par1, 0, 0, 0);
Dieses Kommando dient zur Einstellung der Motorsollfrequenz. Die Motorfrequenzregelung übernimmt dabei die Einhaltung der Beschleunigungs- / Bremsrampe. Schrittverluste treten nicht auf. Die Motorsollfrequenz ist bezogen auf Vollschrittbetrieb. Über das Vorzeichen wird die Richtung ausgewählt. Die Motorsollfrequenz darf nicht über der Maxfrequenz liegen, ansonsten wird das Kommando abgelehnt. Bei geschlossenem Endschalter1 läßt sich nur in positive Richtung verfahren, bei geschlossenem Endschalter2 läßt sich nur in negative Richtung verfahren, ansonsten wird das Kommando abgelehnt.

DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_SET_FREQUENCY_DIRECTLY, par1, 0 ,0 ,0);
Dieses Kommando dient zur Einstellung der Motorfrequenz. Die Motorfrequenzregelung übernimmt dabei keine Funktion. Für die Einhaltung der Beschleunigungs- / Bremsrampe ist der Anwender verantwortlich. Schrittverluste können bei Nichteinhaltung auftreten. Die Motorfrequenz ist bezogen auf Vollschrittbetrieb. Über das Vorzeichen wird die Richtung ausgewählt. Die Frequenz darf nicht über der Maxfrequenz liegen.

ULONG DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_GET_FREQUENCY, 0, 0 ,0 ,0);
Dieses Kommando dient zum Abfragen der Motorfrequenz. Dieses Kommando darf immer verwendet werden.

DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_SET_MOTORCHARACTERISTIC, par1, par2, 0, 0);
Hiermit werden neue Motor Konfigurationen gesetzt

ULONG DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_GET_MOTORCHARACTERISTIC, par1, 0, 0, 0);
Hiermit wird der Motorspezifische Parameter ausgelesen. Dieses Kommando darf immer benutzt werden. Es teilt sich in Unterkommandos auf, die analog den Parametern von DAPI_STEPPER_CMD_SET_MOTORCHARACTERISTIC sind.

DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_MOTORCHARACTERISTIC_LOAD_DEFAULT, 0, 0, 0, 0);
Es wird die Motorcharakteristik des Motors auf Defaultwerte zurück gesetzt.

DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_MOTORCHARACTERISTIC_EEPROM_SAVE, 0, 0, 0, 0);
Es wird die aktuelle Motorcharakteristik des Motors ins EEPROM abgespeichert.

DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_MOTORCHARACTERISTIC_EEPROM_LOAD, 0, 0, 0, 0);
Es wird die Motorcharakteristik des Motors aus dem EEPROM geladen.

ULONG DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_GET_CPU_TEMP, 0, 0, 0, 0);
Die Temperatur des CPU wird abgefragt.

DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_GET_MOTOR_SUPPLY_VOLTAGE, 0, 0, 0, 0);
Hiermit wird die Versorgungsspannung des Motors abgefragt.

ULONG DapiStepperGetStatus(handle, motor, cmd);
Hiermit wird eine bestimmte Position abgelesen

ULONG DapiStepperGetStatus(handle, motor, cmd);
Hiermit wird der Zustand der Schalter abgefragt

ULONG DapiStepperGetStatus(handle, motor, DAPI_STEPPER_STATUS_GET_ACTIVITY);
Hiermit werden verschiedene Statusinformationen (z.B. die Aktivität des Motorstroms, etc.) abgefragt.

ULONG DapiPing(ULONG handle, ULONG value);
Dieser Befehl prüft die Verbindung zu einem geöffneten Modul.

void DapiWriteByte(ULONG handle, ULONG adress, ULONG value);
Dieser Befehl führt einen direkten Register Schreibbefehl auf das Modul aus.

void DapiWriteWord(ULONG handle, ULONG adress, ULONG value);
Dieser Befehl führt einen direkten Register Schreibbefehl auf das Modul aus.

void DapiWriteLong(ULONG handle, ULONG adress, ULONG value);
Dieser Befehl führt einen direkten Register Schreibbefehl auf das Modul aus.

void DapiWriteLongLong(ULONG handle, ULONG adress, ULONGLONG value);
Dieser Befehl führt einen direkten Register Schreibbefehl auf das Modul aus.

ULONG DapiReadByte(ULONG handle, ULONG adress);
Dieser Befehl führt einen direkten Register Lese-Befehl auf das Modul aus.

ULONG DapiReadWord(ULONG handle, ULONG adress);
Dieser Befehl führt einen direkten Register Lese-Befehl auf das Modul aus.

ULONG DapiReadLong(ULONG handle, ULONG adress);
Dieser Befehl führt einen direkten Register Lese-Befehl auf das Modul aus.

ULONGLONG DapiReadLongLong(ULONG handle, ULONG adress);
Dieser Befehl führt einen direkten Register Lese-Befehl auf das Modul aus.