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

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

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

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

Return-Wert
Keiner

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

Unipolare Spannungen (gilt nicht für Module der CAN-Box-Serie)
DAPI_ADDA_MODE_16BIT_UNIPOL_10V
DAPI_ADDA_MODE_16BIT_UNIPOL_5V
DAPI_ADDA_MODE_16BIT_UNIPOL_2V5

Unipolare Spannungen der CAN-Box-Serie
DAPI_ADDA_MODE_16BIT_UNIPOL_40V
(nur CAN-Box 24V-Version)
DAPI_ADDA_MODE_16BIT_UNIPOL_60V
(nur CAN-Box 48V-Version)

Bipolare Spannungen
DAPI_ADDA_MODE_16BIT_BIPOL_10V
DAPI_ADDA_MODE_16BIT_BIPOL_5V
DAPI_ADDA_MODE_16BIT_BIPOL_2V5

Ströme
DAPI_ADDA_MODE_16BIT_0_20mA
DAPI_ADDA_MODE_16BIT_4_20mA
DAPI_ADDA_MODE_16BIT_0_24mA
DAPI_ADDA_MODE_16BIT_0_50mA

Programmierbeispiel

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

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

Definition
ULONG DapiADGetMode(ULONG handle, ULONG ch);

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

Return-Wert
Modus des A/D-Wandlers

Programmierbeispiel

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

Beschreibung
Dieser Befehl liest einen Datenwert von einen Kanal eines A/D-Wandlers.

Definition
ULONG DapiADGet(ULONG handle, ULONG ch);

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

Return-Wert
Wert vom A/D-Wandler in Digits

Bemerkung
Der zurückgelesene Wert muss anhand des eingestellten Modus interpretiert werden. Ist der Modus 0 .. 10V eingestellt, entspricht ein Wert von 0x8000 5V. Ist jedoch der Modus -10 .. 10V eingestellt, entspricht der Wert 0x8000 0V.

Programmierbeispiel

// Ließt den Wert von Kanal 1 aus
unsigned long data;
data = DapiADGet(handle, 0);

Beschreibung
Dieser Befehl liest einen Datenwert von einen Kanal eines A/D-Wandlers in Volt.

Definition
float DapiADGetVolt(ULONG handle, ULONG ch);

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

Return-Wert
Wert vom A/D-Wandler in Volt

Programmierbeispiel

// Ließt den Wert von Kanal 1 in Volt aus
float data;
data = DapiADGetVolt(handle, 0);

Beschreibung
Dieser Befehl liest einen Datenwert eines Kanals eines A/D-Wandlers in mA.

Definition
float DapiADGetmA(ULONG handle, ULONG ch);

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

Return-Wert
Wert vom A/D-Wandler in mA

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

Programmierbeispiel

// Ließt den Wert von Kanal 1 in mA aus
float data;
data = DapiADGetmA(handle, 0);

Beschreibung
Dieser Befehl speichert die Werte bestimmter, 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.

Definition
void DapiSpecialCommand(ULONG handle, DAPI_SPECIAL_CMD_AD, DAPI_SPECIAL_AD_READ_MULTIPLE_AD, ULONG start_ch, ULONG end_ch);

Parameter
handle=Dies ist das Handle eines geöffneten Moduls.
start_ch=Gibt den Start-Kanal des A/D-Wandlers an, ab dem die Werte gepufferten werden (0, 1, 2, ..).
end_ch=Gibt den End-Kanal des A/D-Wandlers an, bis zu dem die Werte gepufferten werden (0, 1, 2, ..).

Return-Wert
Keiner

Bemerkung
Die Werte, die mit Befehl DapiReadMultipleAD gepufferten wurden, können anschließend mit den Befehlen DapiADGetVolt, DapiADGetmA oder DapiADGet gelesen werden. Damit auch wirklich der gepufferte Wert gelesen wird, muss bei diesen Funktionen der Paramater “ch” mit 0x8000 logisch “oder” verknüpft werden (siehe Beispiele).

Programmierbeispiel

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_AD, DAPI_SPECIAL_AD_READ_MULTIPLE_AD, 0, 15);
// Puffert die Werte von A/D-Kanal 0..15

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_AD, DAPI_SPECIAL_AD_READ_MULTIPLE_AD, 0, 63);
// Puffert die Werte von A/D-Kanal 0..63

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_AD, DAPI_SPECIAL_AD_READ_MULTIPLE_AD, 16, 31);
// Puffert die Werte von A/D-Kanal 16..31

value = DapiADGetVolt(handle, 0x8000 | 0);
// Gibt den gepufferten Wert von A/D-Kanal 0 in Volt zurück.

value = DapiADGetmA(handle, 0x8000 | 15);
// Gibt den gepufferten Wert von A/D-Kanal 15 in mA zurück.

value = DapiADGet(handle, 0x8000 | 63);
// Gibt den gepufferten Wert von A/D-Kanal 63 in Digits zurück.

Erklärung
A/D-Wandler mit höherer Auflösung sind sehr präzise Messinstrumente, die bereits kleinste Änderungen am Messsignal erfassen können. In der Praxis
kommt es häufig vor, dass elektrische oder elektromagnetische Störgrößen über die Anschlussleitung auf das Messsignal einwirken und dieses abfälschen. Mit Hilfe eines A/D-Filters lassen sich die Messsignale glätten und optimieren. Der von uns eingesetzte Filter auf Software-Basis ist bereits im Microcontroller integriert worden, durch den der A/D-Wandler angesteuert wird. Per Softwarebefehl können verschiedene Filterlevel eingestellt und auch
zurückgelesen werden. Das Filterprinzip basiert auf einer Mittelwertbildung aus einer Summe von Messungen. Je höher das Filterlevel gewählt wird, desto mehr Messungen werden zur Mittelwertbildung herangezogen. Bedeutet aber auch, dass sich die Abtastrate des A/D-Wandlers mit steigendem Filterlevel reduziert.

Beschreibung
Mit diesem Befehl lässt sich das A/D-Filterlevel Ihres A/D-Moduls festlegen. Je nach Modul, kann die Höhe des einstellbaren Filterlevels variieren.
Bei einem Modul mit mehreren Submodulen kann das A/D-Filterlevel für jedes Submodul einzeln bestimmt werden.
Wird als Filterlevel eine 0 übergeben, wird der Filterlevel deaktiviert.

Definition
void DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_AD, cmd, par1, par2);

Parameter
handle=Dies ist das Handle eines geöffneten Moduls.
cmd=DAPI_SPECIAL_AD_FILTER_SET
par1=((filterlevel & 0xff) << 8) | (submodule_nr & 0xff)
filterlevel: gibt an, welches Filterlevel gesetzt werden soll
submodule_nr: gibt an, auf welchem Submodule der Filter gesetzt werden soll.
Sollte das Modul keine Submodule besitzen wird der Wert 0xff übergeben.
par2 = 0

Return-Wert
Keiner.

Bemerkung
Bei jedem Neustart des Moduls ist der A/D-Filter zunächst ausgeschaltet und
kann bei Bedarf aktiviert werden. Es empfiehlt sich daher, den A/D-Filter in der
Initialisierung Ihres Projektes festzulegen.

Programmierbeispiel

filterlevel = 10
submodule_nr = 0
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_AD,
DAPI_SPECIAL_AD_FILTER_SET, ((filterlevel & 0xff) << 8)
| (submodule_nr & 0xff) , 0);
// A/D-Filter des Submoduls 0 wird auf 10 gesetzt
filterlevel = 5
submodule_nr = 3
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_AD,
DAPI_SPECIAL_AD_FILTER_SET, ((filterlevel & 0xff) << 8)
| (submodule_nr & 0xff) , 0);
// A/D-Filter des Submoduls 3 wird auf 5 gesetzt
filterlevel = 6
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_AD,
DAPI_SPECIAL_AD_FILTER_SET, ((filterlevel & 0xff) << 8)
| (0xff & 0xff) , 0);
// A/D-Filter des Hauptmoduls wird auf 6 setzt (nur bei Modulen ohne
Submodul)
filterlevel = 2
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_AD,
DAPI_SPECIAL_AD_FILTER_SET, ((filterlevel & 0xff) << 8)
| (0xff & 0xff) , 0);
// A/D-Filter des Hauptmoduls wird auf 2 setzt (nur bei Modulen ohne
Submodul)

Beschreibung
Mit diesem Befehl kann die A/D-Filterlevel des A/D-Moduls ausgelesen werden.
Bei einem Modul mit Submodulen muss die Submodulnummer übertragen werden.

Definition
void DT.Delib.DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_AD, cmd, par1, par2);

Parameter
handle=Dies ist das handle eines offenen Moduls.
cmd=DAPI_SPECIAL_AD_FILTER_GET
par1=(submodule_nr & 0xff)
submodule_nr: gibt das Submodul an, aus dem der Filter gelesen werden soll.
Wenn das Modul keine Submodule hat, wird der Wert 0xff übertragen
par2 = 0

Return-Wert
A/D-Filterlevel

Programmierbeispiel

unsigned long filterlevel = DapiSpecialCommand(handle,
DAPI_SPECIAL_CMD_AD, DAPI_SPECIAL_AD_FILTER_GET, (0 &
0xff) , 0);
// A/D-Filter des Submoduls 0 wird ausgelesen
unsigned long filterlevel = DapiSpecialCommand(handle,
DAPI_SPECIAL_CMD_AD, DAPI_SPECIAL_AD_FILTER_GET, (5 &
0xff) , 0);
// A/D-Filter des Submoduls 5 wird ausgelesen
unsigned long filterlevel = DapiSpecialCommand(handle,
DAPI_SPECIAL_CMD_AD, DAPI_SPECIAL_AD_FILTER_GET, (0xff
& 0xff) , 0);
// A/D-Filter des Hauptmoduls wird ausgelesen (nur bei Modulen ohne
Submodul)

Beschreibung
Dieser Befehl liest einen Temperatur Kanal.

Definition
float DapiTempGet(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
Temperatur [°C]

Programmierbeispiel

ret=DapiTempGet(handle, 0)
//gibt die Temperatur von Kanal 0 zurück

Beschreibung
Dieser Befehl liest den Status des Sensors aus.

Definition
float DapiTempGet(ULONG handle, (ULONG par | ULONG ch));

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

Return-Wert
Status des Sensors

Programmierbeispiel

temp_status = DapiTempGet(handle, (DAPI_TEMP_GET_CHAN_GET_STATUS | ch));

if(temp_status == 0)
{
temp_status_text = “Status OK”;
}
else
{
if((temp_status & 1) != 0)
{
temp_status_text = “Sensor offen”;
}
if ((temp_status & 2) != 0) // Short GND
{
temp_status_text = “Short GND”;
}
if ((temp_status & 4) != 0) // Short VCC
{
temp_status_text = “Short VCC”;
}
}

Beschreibung
Dieser Befehl setzt einen Zählmodus (optional auch Submodus) und Eingangsfilter für einen bestimmten Eingangszählerkanal.

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

Parameter
handle=Dies ist das Handle eines geöffneten Moduls
ch=Nummer des Eingangszählerkanals, dessen Modus gesetzt werden soll (0, 1, 2, 3, .. )
mode=Gibt den Modus an

Übersicht verfügbare Zählermodi
Mode:
DAPI_CNT48_MODE_COUNT_RISING_EDGE
DAPI_CNT48_MODE_COUNT_RISING_EDGE_X2
DAPI_CNT48_MODE_COUNT_RISING_EDGE_X4
DAPI_CNT48_MODE_T
DAPI_CNT48_MODE_FREQUENCY
DAPI_CNT48_MODE_PWM

Submode:
DAPI_CNT48_SUBMODE_NO_RESET
DAPI_CNT48_SUBMODE_RESET_WITH_READ
DAPI_CNT48_SUBMODE_NO_RESET
DAPI_CNT48_SUBMODE_RESET_WITH_READ 

Mögliche Werte für mode
mode=DAPI_CNT48_MODE_COUNT_RISING_EDGE |
DAPI_CNT48_SUBMODE_NO_RESET
In diesem Modus wird bei steigender Flanke gezählt.

mode=DAPI_CNT48_MODE_COUNT_RISING_EDGE |
DAPI_CNT48_SUBMODE_RESET_WITH_READ
In diesem Modus wird bei steigender Flanke gezählt. Zusätzlich wird bei jedem Lesevorgang der Zähler resettet.

mode=DAPI_CNT48_MODE_COUNT_RISING_EDGE |
DAPI_CNT48_SUBMODE_RESET_ON_CH_7
In diesem Modus wird bei steigender Flanke gezählt. Zusätzlich kann der Zähler über ein externes Signal (letzer Kanal des Moduls = 1) resettet werden.

mode=DAPI_CNT48_MODE_COUNT_RISING_EDGE |
DAPI_CNT48_SUBMODE_LATCH_COMMON
Mit dem Befehl “DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_CNT48, DAPI_SPECIAL_CNT48_LATCH_GROUP8, 0, 0)” werden alle 8 Zählerstände der Eingangszähler gleichzeitig in einen Zwischenspeicher (Latch) geschrieben. Mit diesem Modus kann dann der gelatchte Zählerstand ausgelesen werden.

mode=DAPI_CNT48_MODE_T
Mit diesem Modus wird die Periodendauer T gemessen. Als Basis hierbei dient ein 100 MHz Zähler.

mode=DAPI_CNT48_MODE_FREQUENCY
Bei diesem Modus lässt sich die Anzahl der steigenden Flanken innerhalb einer Sekunde (=Frequenz) messen.

mode=DAPI_CNT48_MODE_PWM
Mit diesem Modus werden die “high” und “low” Zeit eines Signals gemessen. Dadurch kann anschließend das Verhältnis bestimmt werden (PWM).

Zusätzlich können alle Eingangszähler mit einem Eingangsfilter (mit einer oder-Verknüpfung) kombiniert werden. Hierzu stehen folgende Eingangsfilter zur Verfügung:
DAPI_CNT48_FILTER_20ns
DAPI_CNT48_FILTER_100ns
DAPI_CNT48_FILTER_250ns
DAPI_CNT48_FILTER_500ns
DAPI_CNT48_FILTER_1us
DAPI_CNT48_FILTER_2_5us
DAPI_CNT48_FILTER_5us
DAPI_CNT48_FILTER_10us
DAPI_CNT48_FILTER_25us
DAPI_CNT48_FILTER_50us
DAPI_CNT48_FILTER_100us
DAPI_CNT48_FILTER_250us
DAPI_CNT48_FILTER_500us
DAPI_CNT48_FILTER_1ms
DAPI_CNT48_FILTER_2_5ms
DAPI_CNT48_FILTER_5ms

Bemerkung
Dieser Befehl wird nur von unserem Modul RO-CNT8 unterstützt.

Programmierbeispiel

DapiCnt48ModeSet(handle, 0, DAPI_CNT48_MODE_COUNT_RISING_EDGE | DAPI_CNT48_SUBMODE_RESET_WITH_READ | DAPI_CNT48_FILTER_20ns);
//Eingangszählerkanal 0 zählt alle Impulse <= 20ns bei steigender Flanke. Zusätzlich wird der Zähler nach Abfrage resettet.
DapiCnt48ModeSet(handle, 1, DAPI_CNT48_MODE_COUNT_RISING_EDGE | DAPI_CNT48_SUBMODE_RESET_ON_CH_7 | DAPI_CNT48_FILTER_500us);
//Eingangszählerkanal 1 zählt alle Impulse <= 500us bei steigender Flanke. Dieser Zähler kann mit einem externen Signal (ch7 = 1) resettet werden.
DapiCnt48ModeSet(handle, 2, DAPI_CNT48_MODE_PWM | DAPI_CNT48_FILTER_5ms);
//Eingangszählerkanal 2 misst alle low-/high Zeiten <= 5ms. Anschließend wird das Verhältnis bestimmt (PWM).

Beschreibung
Dieser Befehl liest den Zählmodus eines bestimmten Eingangszählerkanals zurück.

Definition
ULONG DapiCnt48ModeGet(ULONG handle, ULONG ch);

Parameter
handle=Dies ist das Handle eines geöffneten Moduls
ch=Nummer des Eingangszählerkanals, dessen Modus ausgegeben werden soll (0, 1, 2, 3, .. )

Return-Wert
Zählmodus des Eingangszählerkanals.
(Nähere Informationen / Beschreibung der Bits -> siehe delib.h oder Manual “RO-Registerbelegung”)

Bemerkung
Dieser Befehl wird nur von unserem Modul RO-CNT8 unterstützt.

Programmierbeispiel

value = DapiCnt48ModeGet(handle, 0)
//Gibt den Zählmodus von Eingangszählerkanal 0 zurück
value = DapiCnt48ModeGet(handle, 3)
//Gibt den Zählmodus von Eingangszählerkanal 3 zurück

Beschreibung
Dieser Befehl liest die ersten 32 Bit eines 48 Bit Eingangszählers.

Definition
ULONG DapiCnt48CounterGet32(ULONG handle, ULONG ch);

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

Return-Wert
Ausgabe des Zählerwertes.

Bemerkung
Dieser Befehl wird nur von unseren Modulen RO-CNT8 und RO-CNT/IGR unterstützt.

Programmierbeispiel

value = DapiCnt48CounterGet32(handle, 0);
//gibt den Wert von Eingangszählerkanal 0 aus
value = DapiCnt48CounterGet32(handle, 3);
//gibt den Wert von Eingangszählerkanal 3 aus

Beschreibung
Dieser Befehl liest einen 48 Bit Zähler eines Eingangszählerkanals.

Definition
ULONGLONG DapiCnt48CounterGet48(ULONG handle, ULONG ch);

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

Return-Wert
Ausgabe des Zählerwertes.

Bemerkung
Dieser Befehl wird nur von unseren Modulen RO-CNT8 und RO-CNT/IGR unterstützt.

Programmierbeispiel

value = DapiCnt48CounterGet48(handle, 0);
//gibt den Wert von Eingangszählerkanal 0 aus
value = DapiCnt48CounterGet48(handle, 3);
//gibt den Wert von Eingangszählerkanal 3 aus

Beschreibung
Dieser Befehl resettet den Zählerstand eines einzelnen Eingangszählers.

Definition
void DapiSpecialCommand(ULONG handle, DAPI_SPECIAL_CMD_CNT48, DAPI_SPECIAL_CNT48_RESET_SINGLE, ULONG ch, 0)

Parameter
handle=Dies ist das Handle eines geöffneten Moduls
ch=Gibt die Nummer des Eingangszählers an, dessen Zählerstand resettet werden soll (0, 1, 2, ..)

Bemerkung
Dieser Befehl wird nur von unserem Modul RO-CNT8 unterstützt.

Programmierbeispiel

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_CNT48, DAPI_SPECIAL_CNT48_RESET_SINGLE, 0, 0)
// Zählerstand von Eingangszähler 0 wird resettet
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_CNT48, DAPI_SPECIAL_CNT48_RESET_SINGLE, 1, 0)
// Zählerstand von Eingangszähler 1 wird resettet

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

Definition
void DapiSpecialCommand(ULONG handle, DAPI_SPECIAL_CMD_CNT48, DAPI_SPECIAL_CNT48_LATCH_GROUP8, ULONG ch, 0)

Parameter
handle=Dies ist das Handle eines geöffneten Moduls
ch=Gibt die Nummer des Eingangszählers an, ab dem die Zählerstande von 8 Eingangszählern gelatched werden (0, 8, 16, …)

Bemerkung
Dieser Befehl wird nur von unserem Modul RO-CNT8 unterstützt.
Bitte beachten Sie, dass nur die Zählerstände der Eingangszähler gelatched werden, bei denen zuvor der Modus
“DAPI_CNT48_SUBMODE_LATCH_COMMON” gesetzt wurde. (-> DapiCnt48ModeSet)

Programmierbeispiel

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_CNT48, DAPI_SPECIAL_CNT48_LATCH_GROUP8, 0, 0)
// Zählerstände der Eingangszähler 0-7 werden gelatched
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_CNT48, DAPI_SPECIAL_CNT48_LATCH_GROUP8, 8, 0)
// Zählerstände der Eingangszähler 8-15 werden gelatched

Beschreibung
Dieser Befehl resettet gleichzeitig die Zählerstände von 8 Eingangszählern.

Definition
void DapiSpecialCommand(ULONG handle, DAPI_SPECIAL_CMD_CNT48, DAPI_SPECIAL_CNT48_RESET_GROUP8, ULONG ch, 0)

Parameter
handle=Dies ist das Handle eines geöffneten Moduls
ch=Gibt die Nummer des Eingangszählers an, ab dem die Zählerstande von 8 Eingangszählern resettet werden (0, 8, 16, …)

Bemerkung
Dieser Befehl wird nur von unserem Modul RO-CNT8 unterstützt.

Programmierbeispiel

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_CNT48, DAPI_SPECIAL_CNT48_RESET_GROUP8, 0, 0)
// Zählerstände der Eingangszähler 0-7 werden resettet
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_CNT48, DAPI_SPECIAL_CNT48_RESET_GROUP8, 8, 0)
// Zählerstände der Eingangszähler 8-15 werden resettet

Beschreibung
Dieser Befehl liest den Eingangszustand (0/1) eines digitalen Eingangszählerkanals.

Definition
ULONG DapiSpecialCommand(ULONG handle, DAPI_SPECIAL_CMD_CNT48, DAPI_SPECIAL_CNT48_DI_GET1, ULONG ch, 0);

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

Return-Wert
Zustand des Eingangszählers (0/1)

Bemerkung
Dieser Befehl wird nur von unserem Modul RO-CNT8 unterstützt.

Programmierbeispiel

value = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_CNT48, DAPI_SPECIAL_CNT48_DI_GET1, 0, 0)
// Liest Eingangszustand von Eingangszählerkanal 1
value = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_CNT48, DAPI_SPECIAL_CNT48_DI_GET1, 1, 0)
// Liest Eingangszustand von Eingangszählerkanal 2

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

Programmierbeispiel

// Ausgang 8 wird auf 1 gesetzt
DapiDOSet1(handle, 7, 1);

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

Programmierbeispiel

// Ausgänge 9-12 werden auf 0 gesetzt
// Ausgänge 13-16 werden auf 1 gesetzt
DapiDOSet8(handle, 8, 0xf0);

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

Programmierbeispiel

// Ausgänge 1-8 werden auf 0 gesetzt
// Ausgänge 9-16 werden auf 1 gesetzt
DapiDOSet16(handle, 0, 0xff00);

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

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

Programmierbeispiel

// Ausgänge 1-32 werden auf 0 gesetzt
// Ausgänge 33-64 werden auf 1 gesetzt
DapiDOSet64(handle, 0, 0xffffffff00000000);

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.

Programmierbeispiel

// Kanal 1-32 zurücklesen
unsigned long data;
data = DapiDOReadback32(handle, 0);

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

Definition
ULONG DapiDOReadback64(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 64 Ausgängen.

Programmierbeispiel

// Kanal 1-64 zurücklesen
unsigned long data;
data = DapiDOReadback64(handle, 0);

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

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

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

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
Dieser Befehl generiert eine gewisse Anzahl an Impulsen mit vorgegebenen low- und high-Zeiten.

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

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

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

Return-Wert
Keiner

Bemerkung
Wird nur von unseren RO-CNT8 Modulen unterstützt.

Programmierbeispiel

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

Beschreibung
Dieser Befehl setzt das PWM Verhältnis eines PWM-Kanals

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

Parameter
handle=Dies ist das Handle eines geöffneten Moduls
ch=Gibt die Nummer des Ausgangs an, der gesetzt werden soll
data=PWM-Verhältnis in von 0% bis 100% in 1% Schritten
Kleinstes PWM-Verhältnis ist abhängig von der PWM-Frequenz
10Hz data muss >= 0% sein
100Hz data muss >= 2% sein
250Hz data muss >= 3% sein
1000Hz data muss >= 9% sein

Return-Wert
Keiner

Programmierbeispiel

DapiPWMOutSet(handle, 0, 50);
// Sets the pwm ratio of channel 1 to 50% (50% high, 50% low)
DapiPWMOutSet(handle, 1, 100);
// Sets the pwm ratio of channel 2 to 100% (100% high, 0% low)

Beschreibung
Dieser Befehl liest das PWM-Verhältnis eines PWM-Kanals

Definition
float DapiPWMOutReadback(ULONG handle, ULONG ch);

Parameter
handle=Dies ist das Handle eines geöffneten Moduls
ch=Gibt die Nummer des Ausgangs an, der gelesen werden soll

Return-Wert
PWM Verhältnis des Kanals von 0% bis 100%

Programmierbeispiel

float data = DapiPWMOutReadback(handle, 0);
// Reads the pwm ratio of the first channel
float data = DapiPWMOutReadback(handle, 2);
// Reads the pwm ratio of the second channel

Beschreibung
Dieser Befehl setzt die PWM Frequenz des Moduls

Definition
void DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_PWM, cmd, par1, par2);

Parameter
handle=Dies ist das Handle eines geöffneten Moduls
cmd=DAPI_SPECIAL_PWM_FREQ_SET
par1=channel area 0 (ch 0-15), 16 (ch 16-31) … usw.
par2=Frequenz = DAPI_PWM_FREQUENCY_10HZ, DAPI_PWM_FREQUENCY_100HZ, DAPI_PWM_FREQUENCY_250HZ oder DAPI_PWM_FREQUENCY_1000Hz

Return-Wert
Keiner

Programmierbeispiel

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_PWM, DAPI_SPECIAL_PWM_FREQ_SET, 0, DAPI_PWM_FREQUENCY_100HZ);
// Sets the pwm frequency of the module to 100Hz

Beschreibung
Dieser Befehl liest die aktuelle PWM Frequenz des Moduls

Definition
void DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_PWM, cmd, par1, par2);

Parameter
handle=Dies ist das Handle eines geöffneten Moduls
cmd=DAPI_SPECIAL_PWM_FREQ_READBACK
par1=0
par2=0

Return-Wert
uint = DAPI_PWM_FREQUENCY_10HZ, DAPI_PWM_FREQUENCY_100HZ, DAPI_PWM_FREQUENCY_250HZ oder DAPI_PWM_FREQUENCY_1000Hz

Programmierbeispiel

uint frequency = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_PWM, DAPI_SPECIAL_PWM_FREQ_READBACK, 0, 0);
// Reads the pwm frequency of the module

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 dient zum Einstellen des Software FIFO.
Es wird unterschieden zwischen FIFO-OUT (fifo_instance 0 – 3) für D/A- und DOAnwendungen
und FIFO-IN (fifo_instance 4 – 7) für A/D- und DI-Anwendungen.
Weitere Informationen zu den einzelnen Befehlen, finden Sie in den folgenden
Kapiteln und unserem Fifo In/Out Programmierbeispiel.

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 [0..7]
par2 = Wert, der an die Funktion übergeben wird

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

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

Wichtig
Das Interface und die Submodule haben separate Software-Fifos,
deshalb muss der DAPI_SPECIAL_SW_FIFO_INIT_AND_CLEAR Befehl auf beides
angewendet werden.

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.

Beschreibung
Dieser Befehl gibt an, an welches NET-I/O-Modul die Daten des Software FIFO
übergeben werden.
Die Submodulreihenfolge die an das Interface-Module angeschlossenen ist,
bestimmt welche Submodulnummer Sie angeben müssen.

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

Parameter
cmd = DAPI_SPECIAL_SW_FIFO_SET_IOMODULE
fifo_instance = Gibt die Instanz des Software FIFO an
par2 = gibt die Nummer des I/O-Moduls an (0, 1, 2, 3, …)

Programmierbeispiel

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_SET_IOMODULE, fifo_instance, 2);
//Der Software FIFO überträgt die Daten an NET-I/O-Moduls 2.

Beschreibung
Dieser Befehl gibt die Nummer des NET-I/O-Moduls, auf welches die Daten
übertragen werden, zurück.

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

Parameter
cmd = DAPI_SPECIAL_SW_FIFO_GET_IOMODULE
fifo_instance = Gibt die Instanz des Software FIFO an

Programmierbeispiel

unsigned long ret = DapiSpecialCommand(handle,
DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_GET_IOMODULE, fifo_instance, 0);
printf(“Submodule = %lu\n”, ret);
//Die Nummer des NET-I/O-Moduls wird ausgelesen und dargestellt.

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_IOMOD_ACTIVATE
fifo_instance = Gibt die Instanz des Software FIFO an

Programmierbeispiel

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_IOMOD_ACTIVATE, fifo_instance, 0);
//Das automatische Ausgeben der Fifo-Datenübertragung wird aktiviert.

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_IOMOD_DEACTIVATE
fifo_instance = Gibt die Instanz des Software FIFO an

Programmierbeispiel

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_IOMOD_DEACTIVATE, fifo_instance, 0);
//Das automatische Ausgeben der Fifo-Datenübertragung wird deaktiviert.

Beschreibung
Dieser Befehl gibt unter Angabe von Start- und Endkanal an, in welche 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_IOMOD_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 Channel 0
unsigned long ch_end = 1; //End with Channel 1
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_IOMOD_SET_CHANNEL, fifo_instance,
((ch_end << 8) & 0xff00) | (ch_start & 0xff);
//Der Start- und Endkanal wird festgelegt

Beschreibung
Dieser Befehl zeigt die Kanäle, in welche die Daten übertragen werden.

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

Parameter
cmd = DAPI_SPECIAL_SW_FIFO_IOMOD_GET_CHANNEL
fifo_instance = Gibt die Instanz des Software FIFO an

Return-Wert
Nummer der 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_IOMOD_GET_CHANNEL, fifo_instance,
0);
printf(“Channel = %lu\n”, ret);
//Zeigt auf in welche Submodulkanäle die Daten
übertragen werden.

Beschreibung
Dieser Befehl gibt an, mit welcher Frequenz (in Hertz) ..
.. bei Eingabe gelesen wird.
.. bei Ausgabe geschrieben wird.

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

Parameter
cmd = DAPI_SPECIAL_SW_FIFO_IOMOD_SET_FREQUENCY_HZ
fifo_instance = Gibt die Instanz des Software FIFO an
par2 = Frequenz in Hertz (Hz)

Bemerkung
Zulässiger Wertebereich: min 1Hz, max. abhängig vom verwendeten Modul

Programmierbeispiel

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

Beschreibung
Dieser Befehl gibt die eingestellte Frequenz des NET-I/O-Moduls in Hertz wieder.

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

Parameter
cmd = DAPI_SPECIAL_SW_FIFO_IOMOD_GET_FREQUENCY_HZ
fifo_instance = Gibt die Instanz des Software FIFO an

Return-Wert
Frequenz in Hertz (Hz)

Programmierbeispiel

unsigned long ret = DapiSpecialCommand(handle,
DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_IOMOD_GET_FREQUENCY_HZ,
fifo_instance, 0);
printf(“Frequency = %lu (Hz)\n”, ret);
//Zeigt das vorher eingestellte Frequenz des NET-I/O-Moduls an.

Beschreibung
Dieser Befehl setzt den Software FIFO-Mode.

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

Parameter
cmd = DAPI_SPECIAL_SW_FIFO_IOMOD_SET_MODE
fifo_instance = Gibt die Instanz des Software FIFO an

Bemerkung
Der Software FIFO-Mode kann sowohl mit als auch ohne Timestamp (TS) eingestellt werden.

Programmierbeispiel

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

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_IOMOD_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_IOMOD_GET_MODE, fifo_instance, 0);
printf(“Mode = %lu\n”, ret);
//Gibt den vorher eingestellten FIFO Mode wieder.

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_IOMOD_IO_ACTIVATE
fifo_instance = Gibt die Instanz des Software FIFO an

Programmierbeispiel

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

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_IOMOD_IO_DEACTIVATE
fifo_instance = Gibt die Instanz des Software FIFO an

Programmierbeispiel

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

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.

Beschreibung
Dieser Befehl gibt an, wie viel Bytes zum schreiben zur Verfügung stehen.

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

Parameter
cmd = DAPI_SPECIAL_SW_FIFO_IOMOD_GET_BYTES_AVAILABLE
fifo_instance = Gibt die Instanz des Software FIFO an

Return-Wert
Anzahl der Bytes

Programmierbeispiel

unsigned long ret = DapiSpecialCommand(handle,
DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_IOMOD_GET_BYTES_AVAILABLE,
fifo_instance, 0);
printf(“Verfügbaren Bytes = %lu\n”, ret);
//Anzahl Bytes.

Beschreibung
Dieser Befehl gibt an, wie viel Bytes im Software Fifo des Submodules noch frei sind.

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

Parameter
cmd = DAPI_SPECIAL_SW_FIFO_IOMOD_GET_BYTES_FREE
fifo_instance = Gibt die Instanz des Software FIFO an

Return-Wert
Anzahl der Bytes

Programmierbeispiel

unsigned long ret = DapiSpecialCommand(handle,
DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_IOMOD_GET_BYTES_FREE,
fifo_instance, 0);
printf(“Freie Fifo Bytes = %lu\n”, ret);
//Anzahl Bytes.

Beschreibung
Gibt an, wie viele Pakete vom Submodul an den Software Fifo gesendet wurden.

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

Parameter
cmd = DAPI_SPECIAL_SW_FIFO_IOMOD_GET_STAT_TX_CNT
fifo_instance = Gibt die Instanz des Software FIFO an

Return-Wert
Anzahl der Bytes

Programmierbeispiel

unsigned long ret = DapiSpecialCommand(handle,
DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_IOMOD_GET_STAT_TX_CNT,
fifo_instance, 0);
printf(“Gesendete Datenpakete = %lu\n”, ret);
//Ausgabe der Bytes

Beschreibung
Gibt an, wie oft Fehler beim Senden der Datenpakete an den Software Fifo auftraten.
Fehler treten auf, wenn zum Beispiel der Fifo überläuft.

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

Parameter
cmd = DAPI_SPECIAL_SW_FIFO_IOMOD_GET_STAT_TX_ERR_CNT
fifo_instance = Gibt die Instanz des Software FIFO an

Return-Wert
Anzahl der aufgetretenen Fehler beim Senden der Bytes

Programmierbeispiel

unsigned long ret = DapiSpecialCommand(handle,
DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_IOMOD_GET_STAT_TX_ERR_CNT,
fifo_instance, 0);
printf(“Verfügbaren Bytes = %lu\n”, ret);
//Ausgabe der Anzahl an aufgetretenen Fehler beim senden der Bytes

Beschreibung
Gibt an, wie viele Datenpakete vom Software Fifo empfangen wurden.

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

Parameter
cmd = DAPI_SPECIAL_SW_FIFO_IOMOD_GET_STAT_RX_CNT
fifo_instance = Gibt die Instanz des Software FIFO an

Return-Wert
Anzahl der empfangenen Bytes

Programmierbeispiel

unsigned long ret = DapiSpecialCommand(handle,
DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_IOMOD_GET_STAT_RX_CNT,
fifo_instance, 0);
printf(“Verfügbaren Bytes = %lu\n”, ret);
//Anzahl der empfangen Bytes.

Beschreibung
Gibt an, wie oft Fehler beim Empfangen der Datenpakete Fehler auftraten.
Fehler treten auf, wenn keine Daten im Fifo vorhanden sind, ein Abruf aber
stattfindet.

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

Parameter
cmd = DAPI_SPECIAL_SW_FIFO_IOMOD_GET_STAT_RX_ERR_CNT
fifo_instance = Gibt die Instanz des Software FIFO an

Return-Wert
Anzahl der aufgetretenen Fehler beim Empfangen der Bytes

Programmierbeispiel

unsigned long ret = DapiSpecialCommand(handle,
DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_IOMOD_GET_STAT_RX_ERR_CNT,
fifo_instance, 0);
printf(“Verfügbaren Bytes = %lu\n”, ret);
//Ausgabe der Anzahl an aufgetretenen Fehler beim Empfangen der Bytes

Beschreibung
Mit diesem Befehl können Statuswerte abgerufen werden.

Definition
ULONG 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

Programmierbeispiel

unsigned long ret;
ret = DapiSpecialCommand(handle,
DAPI_SPECIAL_CMD_SW_FIFO,DAPI_SPECIAL_SW_FIFO_GET_STATU
S, 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);}

Beschreibung
Dieser Befehl gibt an, wie viel Bytes gesendet wurden.

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

Parameter
cmd = DAPI_SPECIAL_SW_FIFO_GET_STATUS_BYTES_OUT
fifo_instance = Gibt die Instanz des Software FIFO an

Return-Wert
Anzahl der gesendeten Bytes

Programmierbeispiel

unsigned long ret = DapiSpecialCommand(handle,
DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_GET_STATUS_BYTES_OUT,
fifo_instance, 0);
printf(“Bytes gesendet = %lu\n”, ret);
//Ausgabe der bereits gesendeten Bytes

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.

Beschreibung
Mit diesem Befehl wird der Übertragungs-Status des FIFO 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

Beschreibung
Mit diesem Befehl kann ausgelesen werden, bei welchem Kanal es sich um einen Ein- bzw. Ausgangskanal handelt.

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

Parameter
cmd = DAPI_SPECIAL_SW_FIFO_GET_INSTANCE_TYPE
fifo_instance = Gibt die Instanz des Software FIFO an

Return-Wert

Programmierbeispiel

unsigned long ret;
for(int i=0;i!=10;++i)
{
ret = DapiSpecialCommand(handle,
DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_GET_INSTANCE_TYPE, i, 0);
switch(ret)
{
case DAPI_SPECIAL_INSTANCE_TYPE_FIFO_IN:
printf(“Instance %d = FIFO_IN\n\r”, i);break;
case DAPI_SPECIAL_INSTANCE_TYPE_FIFO_OUT:
printf(“Instance %d = FIFO_OUT\n\r”, i);break;
default:
printf(“Instance %d = INVALID\n\r”, i);break;
}
}
//Gibt wieder ob es sich um einen Ein- oder Ausgangskanal handelt

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, type, buffer, buffer_length);
//Schreibt den Datensatz in den Software FIFO.

Beschreibung
Dieser Befehl liest den Software-FIFO aus.

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-Datensatzes

Programmierbeispiel

//Ließt den Datensatz vom Software FIFO
DapiReadFifo(handle, fifo_instance, type, buffer, buffer_length);

Beschreibung
Dieser erweiterte Befehl steuert Schrittmotoren an.

Definition
ULONG DapiStepperCommandEx(ULONG handle, ULONG motor, ULONG cmd, ULONG par1, ULONG par2, ULONG par3, ULONG par4, ULONG par5, ULONG par6, ULONG par7);

Parameter
handle=Dies ist das Handle eines geöffneten Moduls
motor=Nummer des anzusprechenden Motors
cmd=Erweitertes Kommando
par1..7=Erweiterte kommandoabhängige Parameter (s. Bemerkung)

Bemerkung
Siehe delib.h für die erweiterten Kommandos und den zugehörigen Parametern.

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

Definition
DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_GO_POSITION, position, 0, 0, 0);

Parameter
position=Position, die angefahren werden soll

Programmierbeispiel

DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_GO_POSITION , go_pos_par, 0,0,0);

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

Definition
void DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_GO_POSITION_RELATIVE, go_pos_rel_par, 0, 0, 0);

Parameter
go_pos_rel_par=Relative Position, die angefahren werden soll

Programmierbeispiel

DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_GO_POSITION_RELATIVE, 100, 0, 0, 0);
//Motor fährt, von der aktuellen Position aus gesehen, 100 Schritte nach rechts.

Beschreibung
Der Motor fährt zur Referenzposition

Definition
DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_GO_REFSWITCH, par1, par2, par3, 0);

Parameter
Mögliche Werte für par1: (werden mehrere benötigt, müssen die einzelnen addiert werden)
DAPI_STEPPER_GO_REFSWITCH_PAR_REF1
DAPI_STEPPER_GO_REFSWITCH_PAR_REF2
DAPI_STEPPER_GO_REFSWITCH_PAR_REF_LEFT
DAPI_STEPPER_GO_REFSWITCH_PAR_REF_RIGHT
DAPI_STEPPER_GO_REFSWITCH_PAR_REF_GO_POSITIVE
DAPI_STEPPER_GO_REFSWITCH_PAR_REF_GO_NEGATIVE
DAPI_STEPPER_GO_REFSWITCH_PAR_SET_POS_0
par2=Motorpositionsoffset (1/16 Vollschritt)
par3=Timeoutzeit [ms]

Bemerkung
Anfahren des Referenzschalters
Zunächst fährt der Motor zur Referenzposition 1 oder 2 (siehe par1).
Hierbei kann angegeben werden, ob der Referenzschalter 1 (DAPI_STEPPER_GO_REFSWITCH_PAR_REF1) oder der Referenzschalter 2 (DAPI_STEPPER_GO_REFSWITCH_PAR_REF2) angefahren wird.

Dabei läßt sich die Richtung wählen in die der Motor startet. Mit dem Parameter DAPI_STEPPER_GO_REFSWITCH_PAR_REF_GO_NEGATIVE wird nach links und mit dem Parameter DAPI_STEPPER_GO_REFSWITCH_PAR_REF_GO_POSITIVE wird nach rechts gestartet.

Hierbei wird die Geschwindigkeit GOREFERENCEFREQUENCY_TOENDSWITCH benutzt (siehe DapiStepperCommand_SetMotorcharacteristic).

Herausfahren aus dem Referenzschalter
Danach fährt der Motor mit der Geschwindigkeit GOREFERENCEFREQUENCY_AFTERENDSWITCH aus der Referenzposition heraus. Dabei läßt sich wählen, ob der Motor die rechte oder linke Seite des Referenzschalters anfährt. Mit dem Parameter DAPI_STEPPER_GO_REFSWITCH_PAR_REF_LEFT wird die linke Kante angefahren und mit dem Parameter DAPI_STEPPER_GO_REFSWITCH_PAR_REF_RIGHT wird die rechte Kante angefahren.

Optionales Anfahren eines Offsets
Nach dem Herausfahren aus dem Referenzschalter kann noch ein Offset angefahren werden. Falls dieser Parameter nicht = 0 ist (par2), fährt der Motor zu diesem Offset mit der Geschwindigkeit GOREFERENCEFREQUENCY_TOOFFSET.

Nullen der Position des Motors
Mit dem Parameter DAPI_STEPPER_GO_REFSWITCH_PAR_SET_POS_0 kann zusätzlich eingestellt werden, ob der Motor jetzt die Position 0 bekommt.

Programmierbeispiel

DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_GO_REFSWITCH, DAPI_STEPPER_GO_REFSWITCH_PAR_REF1 + DAPI_STEPPER_GO_REFSWITCH_PAR_REF_LEFT + DAPI_STEPPER_GO_REFSWITCH_PAR_REF_GO_POSITIVE + DAPI_STEPPER_GO_REFSWITCH_PAR_SET_POS_0, 0, 15000, 0);

Beschreibung
Dieses Kommando dient zum setzen der Motorposition. Die Auflösung beträgt 1/16 Vollschritt. Dieses Kommando darf nur bei angehaltenem Motor verwendet werden.

Definition
DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_SET_POSITION, par1, 0, 0, 0);

Parameter
par1=Motorposition

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

Definition
DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_SET_FREQUENCY, par1, 0, 0, 0);

Parameter
par1=Motorsollfrequenz [Hz]

Beschreibung
Dieses Kommando dient zum Abfragen der Motorfrequenz. Dieses Kommando darf immer verwendet werden.

Definition
ULONG DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_GET_FREQUENCY, 0, 0 ,0 ,0);

Return-Wert
Motorfrequenz [Hz]

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

Definition
DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_SET_FREQUENCY_DIRECTLY, par1, 0 ,0 ,0);

Parameter
par1=Motorfrequenz [Hz]

Beschreibung
Dieses Kommando dient zum Anhalten des Motors, die Bremsrampe wird dabei eingehalten.

Definition
DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_STOP, 0, 0, 0, 0);

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

Definition
DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_FULLSTOP, 0, 0, 0, 0);

Programmierbeispiel

DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_FULLSTOP , 0, 0, 0, 0);

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

Definition
DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_DISABLE, par1, 0, 0, 0);

Parameter
par1=Disablemode (0=Normale Funktion / 1=Disable)

Beschreibung
Hiermit werden neue Motor Konfigurationen gesetzt

Definition
DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_SET_MOTORCHARACTERISTIC, par1, par2, 0, 0);

Parameter
Parameter-Stepmode setzen
par1=DAPI_STEPPER_MOTORCHAR_PAR_STEPMODE
par2=0 (Vollschrittbetrieb)
par2=1 (Halbschrittbetrieb)
par2=2 (Viertelschrittbetrieb)
par2=3 (Achtelschrittbetrieb)
par2=4 (Sechzehntelschrittbetrieb)

Parameter-GO-Frequency setzen
par1=DAPI_STEPPER_MOTORCHAR_PAR_GOFREQUENCY
par2=Geschwindigkeit [Vollschritt / s] – bezogen auf Vollschritt Frequenz – (Maximalwert=5000)

Parameter-Start-Frequency setzen
par1=DAPI_STEPPER_MOTORCHAR_PAR_STARTFREQUENCY
par2=Startfrequenz [Vollschritt / s] – bezogen auf Vollschritt Frequenz – (Maximalwert=5000)

Parameter-Stop-Frequency setzen
par1=DAPI_STEPPER_MOTORCHAR_PAR_STOPFREQUENCY
par2=Stopfrequenz [Vollschritt / s] – bezogen auf Vollschritt Frequenz – (Maximalwert=5000)

Parameter-Max-Frequency setzen
par1=DAPI_STEPPER_MOTORCHAR_PAR_MAXFREQUENCY
par2=Maximale Frequenz [Vollschritt / s] – bezogen auf Vollschritt Frequenz – (Maximalwert=5000)

Parameter-Accelerationslope setzen
par1=DAPI_STEPPER_MOTORCHAR_PAR_ACCELERATIONSLOPE
par2=Beschleunigungsrampe [Vollschritt / 10ms] – (Maximalwert=1000)

Parameter-Decelerationslope setzen
par1=DAPI_STEPPER_MOTORCHAR_PAR_DECELERATIONSLOPE
par2= Bremsrampe [Vollschritt / 10ms] – (Maximalwert=1000)

Parameter-Phasecurrent setzen
par1=DAPI_STEPPER_MOTORCHAR_PAR_PHASECURRENT
par2=Phasenstrom [mA] – (Maximalwert = 1500)

Parameter-Hold-Phasecurrent setzen
par1=DAPI_STEPPER_MOTORCHAR_PAR_HOLDPHASECURRENT
par2=Phasenstrom bei Motorstillstand [mA] – (Maximalwert=1500)

Parameter-Hold-Time setzen
par1=DAPI_STEPPER_MOTORCHAR_PAR_HOLDTIME
par2=Zeit in der der Haltestrom fließt nach Motorstop [ms]
par2=-1 / FFFF hex / 65535 dez (Zeit unendlich)

Parameter-Status-LED-Mode setzen
par1=DAPI_STEPPER_MOTORCHAR_PAR_STATUSLEDMODE
par2=Betriebsart der Status-LED
par2=0 = (MOVE – LED leuchtet bei Motorbewegung)
par2=1 = (HALT – LED leuchtet bei Motorstillstand)
par2=2 = (ENDSW1 – LED leuchtet bei geschlossenen Endschalter1)
par2=3 = (ENDSW2 – LED leuchtet bei geschlossenen Endschalter2)
par2=4 = (REFSW1 – LED leuchtet bei geschlossenen Referenzschalterschalter1)
par2=5 = (REFSW2 – LED leuchtet bei geschlossenen Referenzschalterschalter2)

Parameter-Invert-END-Switch1 setzen
par1=DAPI_STEPPER_MOTORCHAR_PAR_INVERT_ENDSW1
par2=Invertiere Funktion des Endschalter1 (0=normal / 1=invertieren)

Parameter-Invert-END-Switch2 setzen
par1=DAPI_STEPPER_MOTORCHAR_PAR_INVERT_ENDSW2
par2=Invertiere Funktion des Endschalter2 (0=normal / 1=invertieren)

Parameter-Invert-Ref-Switch1 setzen
par1=DAPI_STEPPER_MOTORCHAR_PAR_INVERT_REFSW1
par2=Invertiere Funktion des Referenzschalterschalter1 (0=normal / 1=invertieren)

Parameter-Invert-Ref-Switch2 setzen
par1=DAPI_STEPPER_MOTORCHAR_PAR_INVERT_REFSW2
par2=Invertiere Funktion des Referenzschalterschalter2 (0=normal / 1=invertieren)

Parameter-Invert-direction setzen
par1=DAPI_STEPPER_MOTORCHAR_PAR_INVERT_DIRECTION
par2=Invertiere alle Richtungsangaben (0=normal / 1=invertieren)

Parameter-Endswitch-Stopmode setzen
par1= DAPI_STEPPER_MOTORCHAR_PAR_ENDSWITCH_STOPMODE
par2=Einstellen des Stopverhaltens (0=Fullstop / 1=Stop)

Parameter-GoReferenceFrequency setzen (ACHTUNG: Dieser Parameter wird nicht mehr unterstützt!)
par1=DAPI_STEPPER_MOTORCHAR_PAR_GOREFERENCEFREQUENCY
Bemerkung: Dieser Parameter wird durch die nachfolgenden drei Parametern vollständig ersetzt.

Parameter-GoReferenceFrequnecyToEndSwitch setzen
par1=DAPI_STEPPER_MOTORCHAR_PAR_GOREFERENCEFREQUENCY_TOENDSWITCH
par2=Geschwindigkeit, mit der der Enschalter angefahren wird (Frequenz [Vollschritt / s] – (Maximalwert=5000))

Parameter GoReferenceFrequencyAfterEndSwitch setzen
par1=DAPI_STEPPER_MOTORCHAR_PAR_GOREFERENCEFREQUENCY_AFTERENDSWITCH
par2=Geschwindigkeit, mit der vom Enschalter abgefahren wird (Frequenz [Vollschritt / s] – (Maximalwert=5000))

Parameter GoReferenceFrequencyToOffset setzen
par1=DAPI_STEPPER_MOTORCHAR_PAR_GOREFERENCEFREQUENCY_TOOFFSET
par2=Geschwindigkeit, mit der der optionale Offset angefahren wird (Frequenz [Vollschritt / s] – (Maximalwert=5000))

Programmierbeispiel

DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_SET_MOTORCHARACTERISTIC , DAPI_STEPPER_MOTORCHAR_PAR_STEPMODE, 4,0,0); // Schrittmode (Voll-, Halb-, Viertel-, Achtel-, Sechszehntelschritt)
DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_SET_MOTORCHARACTERISTIC , DAPI_STEPPER_MOTORCHAR_PAR_GOFREQUENCY, 1000,0,0); // Schrittmode bei Motorstop (Voll-, Halb-, Viertel-, Achtel-, Sechszehntelschritt)
DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_SET_MOTORCHARACTERISTIC , DAPI_STEPPER_MOTORCHAR_PAR_STARTFREQUENCY, 100,0,0); // Startfrequenz [Vollschritt / s]
DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_SET_MOTORCHARACTERISTIC , DAPI_STEPPER_MOTORCHAR_PAR_STOPFREQUENCY, 100,0,0); // Stopfrequenz [Vollschritt / s]
DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_SET_MOTORCHARACTERISTIC , DAPI_STEPPER_MOTORCHAR_PAR_MAXFREQUENCY, 3500,0,0); // maximale Frequenz [Vollschritt / s]
DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_SET_MOTORCHARACTERISTIC , DAPI_STEPPER_MOTORCHAR_PAR_ACCELERATIONSLOPE, 20,0,0); // Beschleunigung in [Vollschritten / ms]
DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_SET_MOTORCHARACTERISTIC , DAPI_STEPPER_MOTORCHAR_PAR_DECELERATIONSLOPE, 20,0,0); // Bremsung in [Vollschritten / ms]
DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_SET_MOTORCHARACTERISTIC , DAPI_STEPPER_MOTORCHAR_PAR_PHASECURRENT, 750,0,0); // Phasenstrom [mA]
DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_SET_MOTORCHARACTERISTIC , DAPI_STEPPER_MOTORCHAR_PAR_HOLDPHASECURRENT, 500,0,0); // Phasenstrom bei Motorstillstand [mA]
DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_SET_MOTORCHARACTERISTIC , DAPI_STEPPER_MOTORCHAR_PAR_HOLDTIME, 15000,0,0); // Zeit in der der Haltestrom fließt nach Motorstop [s]
DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_SET_MOTORCHARACTERISTIC , DAPI_STEPPER_MOTORCHAR_PAR_STATUSLEDMODE, 0,0,0); // Betriebsart der Status-LED
DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_SET_MOTORCHARACTERISTIC , DAPI_STEPPER_MOTORCHAR_PAR_INVERT_ENDSW1, 0,0,0); // invertiere Funktion des Endschalter1
DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_SET_MOTORCHARACTERISTIC , DAPI_STEPPER_MOTORCHAR_PAR_INVERT_ENDSW2, 0,0,0); // invertiere Funktion des Endschalter2
DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_SET_MOTORCHARACTERISTIC , DAPI_STEPPER_MOTORCHAR_PAR_INVERT_REFSW1, 0,0,0); // invertiere Funktion des Referenzschalterschalter1
DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_SET_MOTORCHARACTERISTIC , DAPI_STEPPER_MOTORCHAR_PAR_INVERT_REFSW2, 0,0,0); // invertiere Funktion des Referenzschalterschalter2
DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_SET_MOTORCHARACTERISTIC , DAPI_STEPPER_MOTORCHAR_PAR_INVERT_DIRECTION, 0,0,0); // invertiere alle Richtungsangaben
DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_SET_MOTORCHARACTERISTIC , DAPI_STEPPER_MOTORCHAR_PAR_ENDSWITCH_STOPMODE, 0,0,0); // einstellen des Stopverhaltens
DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_SET_MOTORCHARACTERISTIC , DAPI_STEPPER_MOTORCHAR_PAR_GOREFERENCEFREQUENCY_TOENDSWITCH, 100,0,0); //Einstellung der Geschwindigkeit, mit der zum Endschalter angefahren wird.
DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_SET_MOTORCHARACTERISTIC , DAPI_STEPPER_MOTORCHAR_PAR_GOREFERENCEFREQUENCY_AFTERENDSWITCH , 200,0,0); //Einstellung der Geschwindigkeit, mit der vom Endschalter abgefahren wird.
DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_SET_MOTORCHARACTERISTIC , DAPI_STEPPER_MOTORCHAR_PAR_GOREFERENCEFREQUENCY_TOOFFSET, 300,0,0); //Einstellung der Geschwindigkeit, mit der zum optionalen Offset angefahren wird.

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

Definition
ULONG DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_GET_MOTORCHARACTERISTIC, par1, 0, 0, 0);

Parameter
Parameter-Stepmode abfragen
par1=DAPI_STEPPER_MOTORCHAR_PAR_STEPMODE

Parameter-GO-Frequency abfragen
par1=DAPI_STEPPER_MOTORCHAR_PAR_GOFREQUENCY

Parameter-Start-Frequency abfragen
par1=DAPI_STEPPER_MOTORCHAR_PAR_STARTFREQUENCY

Parameter-Stop-Frequency abfragen
par1=DAPI_STEPPER_MOTORCHAR_PAR_STOPFREQUENCY

Parameter-Max-Frequency abfragen
par1=DAPI_STEPPER_MOTORCHAR_PAR_MAXFREQUENCY

Parameter-Accelerationslope abfragen
par1=DAPI_STEPPER_MOTORCHAR_PAR_ACCELERATIONSLOPE

Parameter-Decelerationslope abfragen
par1=DAPI_STEPPER_MOTORCHAR_PAR_DECELERATIONSLOPE

Parameter-Phasecurrent abfragen
par1=DAPI_STEPPER_MOTORCHAR_PAR_PHASECURRENT

Parameter-Hold-Phasecurrent abfragen
par1=DAPI_STEPPER_MOTORCHAR_PAR_HOLDPHASECURRENT

Parameter-Hold-Time abfragen
par1=DAPI_STEPPER_MOTORCHAR_PAR_HOLDTIME

Parameter-Status-LED-Mode abfragen
par1=DAPI_STEPPER_MOTORCHAR_PAR_STATUSLEDMODE

Parameter-Invert-END-Switch1 abfragen
par1=DAPI_STEPPER_MOTORCHAR_PAR_INVERT_ENDSW1

Parameter-Invert-END-Switch2 abfragen
par1=DAPI_STEPPER_MOTORCHAR_PAR_INVERT_ENDSW2

Parameter-Invert-Ref-Switch1 abfragen
par1=DAPI_STEPPER_MOTORCHAR_PAR_INVERT_REFSW1

Parameter-Invert-Ref-Switch2 abfragen
par1=DAPI_STEPPER_MOTORCHAR_PAR_INVERT_REFSW2

Parameter-Invert-direction abfragen
par1=DAPI_STEPPER_MOTORCHAR_PAR_INVERT_DIRECTION

Parameter-Endswitch-Stopmode abfragen
par1= DAPI_STEPPER_MOTORCHAR_PAR_ENDSWITCH_STOPMODE

Parameter-GoReferenceFrequency abfragen (ACHTUNG: Dieser Parameter wird nicht mehr unterstützt!)
par1=DAPI_STEPPER_MOTORCHAR_PAR_GOREFERENCEFREQUENCY
Bemerkung: Dieser Parameter wird durch die nachfolgenden drei Parametern vollständig ersetzt.

Parameter-GoReferenceFrequnecyToEndSwitch abfragen
par1=DAPI_STEPPER_MOTORCHAR_PAR_GOREFERENCEFREQUENCY_TOENDSWITCH

Parameter GoReferenceFrequencyAfterEndSwitch abfragen
par1=DAPI_STEPPER_MOTORCHAR_PAR_GOREFERENCEFREQUENCY_AFTERENDSWITCH

Parameter GoReferenceFrequencyToOffSet abfragen
par1=DAPI_STEPPER_MOTORCHAR_PAR_GOREFERENCEFREQUENCY_TOOFFSET

Return-Wert
Parameter-Stepmode abfragen
par1=DAPI_STEPPER_MOTORCHAR_PAR_STEPMODE
return=0 (Vollschrittbetrieb)
return=1 (Halbschrittbetrieb)
return=2 (Viertelschrittbetrieb)
return=3 (Achtelschrittbetrieb)
return=4 (Sechzehntelschrittbetrieb)

Parameter-GO-Frequency abfragen
par1=DAPI_STEPPER_MOTORCHAR_PAR_GOFREQUENCY
return=Geschwindigkeit [Vollschritt / s] – bezogen auf Vollschritt

Parameter-Start-Frequency abfragen
par1=DAPI_STEPPER_MOTORCHAR_PAR_STARTFREQUENCY
return=Startfrequenz [Vollschritt / s]

Parameter-Stop-Frequency abfragen
par1=DAPI_STEPPER_MOTORCHAR_PAR_STOPFREQUENCY
return=Stopfrequenz [Vollschritt / s]

Parameter-Max-Frequency abfragen
par1=DAPI_STEPPER_MOTORCHAR_PAR_MAXFREQUENCY
return=maximale Frequenz [Vollschritt / s]

Parameter-Accelerationslope abfragen
par1=DAPI_STEPPER_MOTORCHAR_PAR_ACCELERATIONSLOPE
return=Beschleunigungsrampe [Vollschritt / 10ms]

Parameter-Decelerationslope abfragen
par1=DAPI_STEPPER_MOTORCHAR_PAR_DECELERATIONSLOPE
return=Bremsrampe [Vollschritt / 10ms]

Parameter-Phasecurren abfragen
par1=DAPI_STEPPER_MOTORCHAR_PAR_PHASECURRENT
return=Phasenstrom [mA]

Parameter-Hold-Phasecurrent abfragen
par1=DAPI_STEPPER_MOTORCHAR_PAR_HOLDPHASECURRENT
return= Phasenstrom bei Motorstillstand [mA]

Parameter-Hold-Time abfragen
par1=DAPI_STEPPER_MOTORCHAR_PAR_HOLDTIME
return=Zeit in der der Haltestrom fließt nach Motorstop [ms]

Parameter-Status-LED-Mode abfragen
par1=DAPI_STEPPER_MOTORCHAR_PAR_STATUSLEDMODE
return=Betriebsart der Status-LED
return=0 (MOVE – LED leuchtet bei Motorbewegung)
return=1 (HALT – LED leuchtet bei Motorstillstand)
return=2 (ENDSW1 – LED leuchtet bei geschlossenen Endschalter1)
return=3 (ENDSW2 – LED leuchtet bei geschlossenen Endschalter2)
return=4 (REFSW1 – LED leuchtet bei geschlossenen Referenzschalterschalter1)
return=5 (REFSW2 – LED leuchtet bei geschlossenen Referenzschalterschalter2)

Parameter-Invert-END-Switch1 abfragen
par1=DAPI_STEPPER_MOTORCHAR_PAR_INVERT_ENDSW1
return=Endschalter1 wird invertiert (0=normal / 1=invertieren)

Parameter-Invert-END-Switch2 abfragen
par1=DAPI_STEPPER_MOTORCHAR_PAR_INVERT_ENDSW2
return=Endschalter2 wird invertiert (0=normal / 1=invertieren)

Parameter-Invert-Ref-Switch1 abfragen
par1=DAPI_STEPPER_MOTORCHAR_PAR_INVERT_REFSW1
return=Referenzschalterschalter1 wird invertiert (0=normal / 1=invertieren)

Parameter-Invert-Ref-Switch2 abfragen
par1=DAPI_STEPPER_MOTORCHAR_PAR_INVERT_REFSW2
return=Referenzschalterschalter2 wird invertiert (0=normal / 1=invertieren)

Parameter-Invert-Direction abfragen
par1=DAPI_STEPPER_MOTORCHAR_PAR_INVERT_DIRECTION
return=Richtungsangaben werden invertriert (0=normal / 1=invertieren)

Parameter-Endswitch-Stopmode abfragen
par1=DAPI_STEPPER_MOTORCHAR_PAR_ENDSWITCH_STOPMODE
return=Einstellung des Stopverhaltens (0=Fullstop / 1=Stop)

Parameter-GoReferenceFrequnecyToEndSwitch abfragen
par1=DAPI_STEPPER_MOTORCHAR_PAR_GOREFERENCEFREQUENCY_TOENDSWITCH
return=Frequenz [Vollschritt / s]

Parameter GoReferenceFrequencyAfterEndSwitch abfragen
par1=DAPI_STEPPER_MOTORCHAR_PAR_GOREFERENCEFREQUENCY_AFTERENDSWITCH
return=Frequenz [Vollschritt / s]

Parameter GoReferenceFrequencyToOffset abfragen
par1=DAPI_STEPPER_MOTORCHAR_PAR_GOREFERENCEFREQUENCY_TOOFFSET
return=Frequenz [Vollschritt / s]

Programmierbeispiel

value = DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_GET_MOTORCHARACTERISTIC , DAPI_STEPPER_MOTORCHAR_PAR_STEPMODE, 0, 0, 0); // Schrittmode (Voll-, Halb-, Viertel-, Achtel-, Sechszehntelschritt)
value = DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_GET_MOTORCHARACTERISTIC , DAPI_STEPPER_MOTORCHAR_PAR_GOFREQUENCY, 0,0,0); // Schrittmode bei Motorstop (Voll-, Halb-, Viertel-, Achtel-, Sechszehntelschritt)
value = DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_GET_MOTORCHARACTERISTIC , DAPI_STEPPER_MOTORCHAR_PAR_STARTFREQUENCY, 0,0,0); // Startfrequenz [Vollschritt / s]
value = DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_GET_MOTORCHARACTERISTIC , DAPI_STEPPER_MOTORCHAR_PAR_STOPFREQUENCY, 0,0,0); // Stopfrequenz [Vollschritt / s]
value = DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_GET_MOTORCHARACTERISTIC , DAPI_STEPPER_MOTORCHAR_PAR_MAXFREQUENCY, 0,0,0); // maximale Frequenz [Vollschritt / s]
value = DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_GET_MOTORCHARACTERISTIC , DAPI_STEPPER_MOTORCHAR_PAR_ACCELERATIONSLOPE, 0,0,0); // Beschleunigun in [Vollschritten / ms]
value = DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_GET_MOTORCHARACTERISTIC , DAPI_STEPPER_MOTORCHAR_PAR_DECELERATIONSLOPE, 0,0,0); // Bremsung in [Vollschritten / ms]
value = DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_GET_MOTORCHARACTERISTIC , DAPI_STEPPER_MOTORCHAR_PAR_PHASECURRENT, 0,0,0); // Phasenstrom [mA]
value = DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_GET_MOTORCHARACTERISTIC , DAPI_STEPPER_MOTORCHAR_PAR_HOLDPHASECURRENT, 0,0,0); // Phasenstrom bei Motorstillstand [mA]
value = DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_GET_MOTORCHARACTERISTIC , DAPI_STEPPER_MOTORCHAR_PAR_HOLDTIME, 0,0,0); // Zeit in der der Haltestrom fließt nach Motorstop [s]
value = DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_GET_MOTORCHARACTERISTIC , DAPI_STEPPER_MOTORCHAR_PAR_STATUSLEDMODE, 0,0,0); // Betriebsart der Status-LED
value = DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_GET_MOTORCHARACTERISTIC , DAPI_STEPPER_MOTORCHAR_PAR_INVERT_ENDSW1, 0,0,0); // invertiere Funktion des Endschalter1
value = DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_GET_MOTORCHARACTERISTIC , DAPI_STEPPER_MOTORCHAR_PAR_INVERT_ENDSW2, 0,0,0); // invertiere Funktion des Endschalter12
value = DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_GET_MOTORCHARACTERISTIC , DAPI_STEPPER_MOTORCHAR_PAR_INVERT_REFSW1, 0,0,0); // invertiere Funktion des Referenzschalterschalter1
value = DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_GET_MOTORCHARACTERISTIC , DAPI_STEPPER_MOTORCHAR_PAR_INVERT_REFSW2, 0,0,0); // invertiere Funktion des Referenzschalterschalter2
value = DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_GET_MOTORCHARACTERISTIC , DAPI_STEPPER_MOTORCHAR_PAR_INVERT_DIRECTION, 0,0,0); // invertiere alle Richtungsangaben
value = DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_GET_MOTORCHARACTERISTIC , DAPI_STEPPER_MOTORCHAR_PAR_ENDSWITCH_STOPMODE, 0,0,0); // einstellen des Stopverhaltens
value = DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_GET_MOTORCHARACTERISTIC ,
DAPI_STEPPER_MOTORCHAR_PAR_GOREFERENCEFREQUENCY_TOENDSWITCH, 0,0,0); // Abfrage der Geschwindigkeit, mit der der Endschalter angefahren wird.
value = DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_GET_MOTORCHARACTERISTIC ,
DAPI_STEPPER_MOTORCHAR_PAR_GOREFERENCEFREQUENCY_AFTERENDSWITCH, 0,0,0); // Abfrage der Geschwindigkeit, mit der vom Endschalter abgefahren wird.
value = DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_GET_MOTORCHARACTERISTIC ,
DAPI_STEPPER_MOTORCHAR_PAR_GOREFERENCEFREQUENCY_TOOFFSET, 0,0,0); // Abfrage der Geschwindigkeit, mit der der optionale Offset angefahren wird

Beschreibung
Es wird die aktuelle Motorcharakteristik des Motors ins EEPROM abgespeichert.

Definition
DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_MOTORCHARACTERISTIC_EEPROM_SAVE, 0, 0, 0, 0);

Beschreibung
Es wird die Motorcharakteristik des Motors aus dem EEPROM geladen.

Definition
DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_MOTORCHARACTERISTIC_EEPROM_LOAD, 0, 0, 0, 0);

Beschreibung
Es wird die Motorcharakteristik des Motors auf Defaultwerte zurück gesetzt.

Definition
DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_MOTORCHARACTERISTIC_LOAD_DEFAULT, 0, 0, 0, 0);

Bemerkung
Die Defaultwerte sind folgende:
– Stepmode: Vollschritt
– Schrittfrequenz bei GoPosition [Vollschritt / s]: 1000 Hz
– Startfrequenz [Vollschritt / s]: 200Hz
– Stopfrequenz [Vollschritt / s]: 200Hz
– Maximale Schrittfrequenz [Vollschritt / s]: 3000Hz
– Beschleunigungsrampe [Hz/10ms]: 10Hz/10ms
– Bremsrampe [Hz/10ms]: 10Hz/10ms
– Phasenstrom 0..1,5A [1mA]: 750mA
– Haltestorm 0..1,5A [1mA]: 500mA
– Haltezeit 0..unendlich [ms]: 15000ms
– Status_LEDfunktion: Move
– Funktion des Endschalter1: nicht invertiert
– Funktion des Endschalter2: nicht invertiert
– Funktion des Referenzschalter1: nicht invertiert
– Funktion des Referenzschalter2: nicht invertiert
– Funktion aller Richtungsangaben: nicht invertiert
– Endschaltermode: Fullstop
– Schrittfrequenz bei GoReferenz [Vollschritt / s]: 1000 Hz

Beschreibung
Die Temperatur des CPU wird abgefragt.

Definition
ULONG DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_GET_CPU_TEMP, 0, 0, 0, 0);

Parameter
cmd=DAPI_STEPPER_CMD_GET_CPU_TEMP

Return-Wert
Temperatur [°C]

Beschreibung
Hiermit wird die Versorgungsspannung des Motors abgefragt.

Definition
DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_GET_MOTOR_SUPPLY_VOLTAGE, 0, 0, 0, 0);

Parameter
cmd=DAPI_STEPPER_CMD_GET_MOTOR_SUPPLY_VOLTAGE

Return-Wert
Motorversorgungsspannung in [mV]

Beschreibung
Hiermit werden verschiedene Statusinformationen (z.B. die Aktivität des Motorstroms, etc.) abgefragt.

Definition
ULONG DapiStepperGetStatus(handle, motor, DAPI_STEPPER_STATUS_GET_ACTIVITY);

Parameter
handle=Dies ist das Handle eines geöffneten Moduls
motor=Nummer des anzusprechenden Motors

Return-Wert
Bit Command Beschreibung
0 DISABLE Motor darf nicht verfahren
1 MOTORSTROMACTIV Motorstrom ist aktiv
2 HALTESTROMACTIV Haltestrom ist aktiv
3 GOPOSITIONACTIV GoPosition ist aktiv
4 GOPOSITIONBREMSEN GoPosition Bremsung ist aktiv
5 GOREFERENZACTIV GoReference ist aktiv

Programmierbeispiel

ret = DapiStepperGetStatus(handle, motor, DAPI_STEPPER_STATUS_GET_ACTIVITY);

Beschreibung
Hiermit wird eine bestimmte Position abgelesen

Definition
ULONG DapiStepperGetStatus(handle, motor, cmd);

Parameter
cmd=DAPI_STEPPER_STATUS_GET_POSITION

Return-Wert
Es wird die aktuelle Motorposition in 1/16 Schritteinheiten zurückgegeben

Programmierbeispiel

value = DapiStepperGetStatus(handle, motor, DAPI_STEPPER_STATUS_GET_POSITION);

Beschreibung
Hiermit wird der Zustand der Schalter abgefragt

Definition
ULONG DapiStepperGetStatus(handle, motor, cmd);

Parameter
cmd=DAPI_STEPPER_STATUS_GET_SWITCH

Return-Wert
Es wird der Zustand der Schalter zurückgeliefert:
Bit0: ENDSCHALTER1; 1 = Endschalter1 ist geschlossen
Bit1: ENDSCHALTER2; 1 = Endschalter2 ist geschlossen
Bit2: REFSCHALTER1; 1 = Referenzschalter1 ist geschlossen
Bit3: REFSCHALTER2; 1 = Referenzschalter2 ist geschlossen

Programmierbeispiel

pos = DapiStepperGetStatus(handle, motor, DAPI_STEPPER_STATUS_GET_SWITCH);

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

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.

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.

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.

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.

Beschreibung
Dieser Befehl setzt die Richtung von 8 hintereinanderliegenden TTL-Ein/Ausgängen (1-Bit weise).

Definition
void DapiSpecialCommand(ULONG handle, DAPI_SPECIAL_CMD_SET_DIR_DX_1, ULONG ch, ULONG dir, 0);

Parameter
handle = Dies ist das Handle eines geöffneten Moduls
ch = Muss immer 0 sein!
dir = Gibt die Richtung für 8 Kanäle an (1=output / 0=input) / Bit 0 steht für Kanal 0, Bit 1 für Kanal 1 …

Return-Wert
Keiner

Bemerkung
Nicht kompatibel mit USB-TTL-32/64.
Verwenden Sie für diese Module den DAPI_SPECIAL_CMD_SET_DIR_DX_8 Befehl.

Programmierbeispiel

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SET_DIR_DX_1, 0, 0x01 , 0);
// Set Dir of TTL-I/O CH0 to output, others to input
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SET_DIR_DX_1, 0, 0x02 , 0);
// Set Dir of TTL-I/O CH1 to output, others to input
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SET_DIR_DX_1, 0, 0x04 , 0);
// Set Dir of TTL-I/O CH2 to output, others to input
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SET_DIR_DX_1, 0, 0x08 , 0);
// Set Dir of TTL-I/O CH3 to output, others to input
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SET_DIR_DX_1, 0, 0x10 , 0);
// Set Dir of TTL-I/O CH4 to output, others to input
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SET_DIR_DX_1, 0, 0x20 , 0);
// Set Dir of TTL-I/O CH5 to output, others to input
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SET_DIR_DX_1, 0, 0x40 , 0);
// Set Dir of TTL-I/O CH6 to output, others to input
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SET_DIR_DX_1, 0, 0x80 , 0);
// Set Dir of TTL-I/O CH7 to output, others to input
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SET_DIR_DX_1, 0, 0x0f , 0);
// Set Dir of TTL-I/O CH0-3 to output, others to input
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SET_DIR_DX_1, 0, 0xff , 0);
// Set Dir of TTL-I/O CH0-7 to output, others to input

Beschreibung
Dieser Befehl setzt die Richtung von bis zu 64 hintereinanderliegenden TTL-Ein/Ausgängen (8-Bit weise).
1-Bit repräsentiert dabei 8 TTL-Ein/Ausgänge.

Definition
void DapiSpecialCommand(ULONG handle, DAPI_SPECIAL_CMD_SET_DIR_DX_8, ULONG ch, ULONG dir, 0);

Parameter
handle = Dies ist das Handle eines geöffneten Moduls
ch = Muss immer 0 sein!
dir = (8-Bit) gibt die Richtung für bis zu 64 hintereinanderliegende TTL-Ein/Ausgänge an. (1=output / 0=input)

Return-Wert
Keiner

Bemerkung
Nur kompatibel mit USB-TTL-32/64.
Verwenden Sie für andere TTL-Produkte den DAPI_SPECIAL_CMD_SET_DIR_DX_1 Befehl.

Programmierbeispiel

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SET_DIR_DX_8, 0, 0x1 , 0);
// Set Dir of TTL-I/O CH0-7 to output, others to input
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SET_DIR_DX_8, 0, 0x3 , 0);
// Set Dir of TTL-I/O CH0-15 to output, others to input
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SET_DIR_DX_8, 0, 0xc , 0);
// Set Dir of TTL-I/O CH16-31 to output, others to input
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SET_DIR_DX_8, 0, 0x33 , 0);
// Set Dir of TTL-I/O CH0-15 and CH32-47 to output, others to input
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SET_DIR_DX_8, 0, 0xff , 0);
// Set Dir of TTL-I/O CH0-63 to output, others to input

Beschreibung
Dieser Befehl liest die Richtung von bis zu 64 hintereinanderliegenden TTL-Ein/Ausgängen (8-Bit weise).
1-Bit repräsentiert dabei 8 TTL-Ein/Ausgänge.

Definition
ULONG DapiSpecialCommand(ULONG handle, DAPI_SPECIAL_CMD_GET_DIR_DX_8, ULONG ch, ULONG dir, 0);

Parameter
handle = Dies ist das Handle eines geöffneten Moduls
ch = Muss immer 0 sein!
dir = Muss immer 0 sein!

Return-Wert
Richtungszustand von 64 Kanälen.

Bit 0: Richtung von TTL 0-7       / 1=Output, 0=Input
Bit 1: Richtung von TTL 8-15     / 1=Output, 0=Input
Bit 2: Richtung von TTL 16-23   / 1=Output, 0=Input
Bit 3: Richtung von TTL 24-31   / 1=Output, 0=Input
Bit 4: Richtung von TTL 32-39   / 1=Output, 0=Input
Bit 5: Richtung von TTL 40-47   / 1=Output, 0=Input
Bit 6: Richtung von TTL 48-55   / 1=Output, 0=Input
Bit 7: Richtung von TTL 56-63   / 1=Output, 0=Input

Bemerkung
Nur kompatibel mit USB-TTL-32/64.

Programmierbeispiel

ULONG ret = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_GET_DIR_DX_8, 0, 0, 0);
// Liest die Richtung von 64 Kanälen aus

Beschreibung
Diese Funktion aktiviert den Watchdog.

Definition
void DapiWatchdogEnable(ULONG handle);

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

Return-Wert
Keiner

Programmierbeispiel

DapiWatchdogEnable(handle);
//Aktiviert den Watchdog

Beschreibung
Diese Funktion deaktiviert den Watchdog.

Definition
void DapiWatchdogDisable(ULONG handle);

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

Return-Wert
Keiner

Programmierbeispiel

DapiWatchdogDisable(handle);
//Deaktiviert den Watchdog

Beschreibung
Diese Funktion retriggert den Watchdog-Timer.

Definition
void DapiWatchdogRetrigger(ULONG handle);

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

Return-Wert
Keiner

Programmierbeispiel

DapiWatchdogRetrigger(handle);
//Retriggert den Watchdog-Timer

Beschreibung
Diese Funktion gibt verschiedene Status Informationen des Watchdog-Sticks zurück oder setzt diese.

Definition
ULONG DapiSpecialCommand(ULONG handle, DAPI_SPECIAL_CMD_WATCHDOG, cmd, par1, 0);

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

Abfragen des Timeout-Relais Zählers
cmd=DAPI_SPECIAL_WATCHDOG_GET_TIMEOUT_RELAIS_COUNTER_MSEC
par1=0

Abfragen des Watchdog-Status
cmd=DAPI_SPECIAL_WATCHDOG_GET_STATUS
par1=0

Abfragen der momentanen Timeout-Zeit
cmd=DAPI_SPECIAL_WATCHDOG_GET_TIMEOUT_MSEC
par1=0

Abfragen des Watchdog Timeout-Zählers
cmd=DAPI_SPECIAL_WATCHDOG_GET_WD_COUNTER_MSEC
par1=0

Setzen der Zeit, wie lange Relais 1 geschaltet wird
cmd=DAPI_SPECIAL_WATCHDOG_SET_TIMEOUT_REL1_COUNTER_MSEC
par1=Zeit, wie lange das 1.Relais geschaltet wird [ms]

Setzen der Zeit, wie lange Relais 2 geschaltet wird
cmd=DAPI_SPECIAL_WATCHDOG_SET_TIMEOUT_REL2_COUNTER_MSEC
par1=Zeit, wie lange das 2.Relais geschaltet wird [ms]

Return-Wert
Abfragen des Timeout-Relais Zählers
return=Vergangene Zeit nach einem Timeout [ms]

Abfragen des Watchdog-Status
return=Watchdog-Status
return=0 = Watchdog ist deaktiviert
return=1 = Watchdog ist aktiviert
return=2 = Watchdog ist retriggered
return=3 = Watchdog Timeout

Abfragen der momentanen Timeout-Zeit
return=Timeout-Zeit [ms]

Abfragen des Watchdog Timeout-Zählers
return=Vergangene Zeit ohne Retrigger [ms]

Programmierbeispiel

return = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_WATCHDOG, DAPI_SPECIAL_WATCHDOG_GET_TIMEOUT_RELAIS_COUNTER_MSEC, 0, 0);
//Abfragen des Timeout-Relais Zählers
return = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_WATCHDOG, DAPI_SPECIAL_WATCHDOG_GET_STATUS, 0, 0);
//Abfragen des Watchdog-Status
return = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_WATCHDOG, DAPI_SPECIAL_WATCHDOG_GET_TIMEOUT_MSEC, 0, 0);
//Abfragen der momentan benutzten Timeout-Zeit
return = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_WATCHDOG, DAPI_SPECIAL_WATCHDOG_GET_WD_COUNTER_MSEC, 0, 0);
//Abfragen des Watchdog Timeout-Zählers

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_WATCHDOG, DAPI_SPECIAL_WATCHDOG_SET_TIMEOUT_REL1_COUNTER_MSEC, 500, 0);
//Schaltet das 1.Relais nach einem Timeout für 500 ms
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_WATCHDOG, DAPI_SPECIAL_WATCHDOG_SET_TIMEOUT_REL1_COUNTER_MSEC, 700, 0);
//Schaltet das 2.Relais nach einem Timeout für 700 ms