Verwaltungsfunktionen

DapiOpenModule
Diese Funktion öffnet ein bestimmtes Modul.

DapiOpenModule

Beschreibung

Diese Funktion öffnet ein bestimmtes Modul

 

Definition

ULONG DapiOpenModule(ULONG moduleID, ULONG nr);

 

Parameter

moduleID=Gibt das Modul an, welches geöffnet werden soll (siehe delib.h)
nr=Gibt an, welches (bei mehreren Modulen) geöffnet werden soll.
nr=0 -> 1. Modul
nr=1 -> 2. Modul

 

Return-Wert

handle=Entsprechender Handle für das Modul
handle=0 -> Modul wurde nicht gefunden

 

Bemerkung

Der von dieser Funktion zurückgegebe Handle wird zur Identifikation des Moduls für alle anderen Funktionen benötigt.

 

Programmierbeispiel

// USB-Modul öffnen
handle = DapiOpenModule(RO_USB1, 0);
printf(“handle = %x\n”, handle);
if (handle==0)
{
// USB Modul wurde nicht gefunden
printf(“Modul konnte nicht geöffnet werden\n”);
return;
}

DapiCloseModule
Dieser Befehl schliesst ein geöffnetes Modul.

DapiCloseModule

Beschreibung

Dieser Befehl schliesst ein geöffnetes Modul.

 

Definition

ULONG DapiCloseModule(ULONG handle);

 

Parameter

handle=Dies ist das Handle eines geöffneten Moduls

 

Return-Wert

Keiner

 

Programmierbeispiel

// Modul schliessen
DapiCloseModule(handle);

DapiGetLastError
Diese Funktion liefert den letzten erfassten Fehler. Sofern ein Fehler aufgetreten ist, muss dieser mit DapiClearLastError() gelöscht werden, da sonst jeder Aufruf von DapiGetLastError() den "alten" Fehler zurückgibt. Sollen mehrere Module verwendet werden, empfielt sich die Verwendung von DapiGetLastErrorByHandle().

DapiGetLastError

 

Beschreibung

Diese Funktion liefert den letzten erfassten Fehler. Sofern ein Fehler aufgetreten ist, muss dieser mit DapiClearLastError() gelöscht werden, da sonst jeder Aufruf von DapiGetLastError() den “alten” Fehler zurückgibt.
Sollen mehrere Module verwendet werden, empfielt sich die Verwendung von DapiGetLastErrorByHandle().

 

Definition

ULONG DapiGetLastError(void);

 

Parameter

Keine

 

Return-Wert

Fehler Code
0=kein Fehler. (siehe delib_error_codes.h)

 

Programmierbeispiel

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

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

DapiClearLastError();

return TRUE;
}

return FALSE;
}

DapiGetLastErrorByHandle
Diese Funktion liefert den letzten erfassten Fehler eines bestimmten Moduls (handle). Sofern ein Fehler aufgetreten ist, muss dieser mit DapiClearLastErrorByHandle() gelöscht werden, da sonst jeder Aufruf von DapiGetLastErrorByHandle() den "alten" Fehler zurückgibt.

DapiGetLastErrorByHandle

 

Beschreibung

Diese Funktion liefert den letzten erfassten Fehler eines bestimmten Moduls (handle). Sofern ein Fehler aufgetreten ist, muss dieser mit DapiClearLastErrorByHandle() gelöscht werden, da sonst jeder Aufruf von DapiGetLastErrorByHandle() den “alten” Fehler zurückgibt.

 

Definition

ULONG DapiGetLastErrorByHandle(ULONG handle);

 

Parameter

handle=Dies ist das Handle eines geöffneten Moduls

 

Return-Wert

Fehler Code
0=kein Fehler. (siehe delib_error_codes.h)

 

Programmierbeispiel

BOOL IsError(ULONG handle)
{
unsigned long error_code = DapiGetLastErrorByHandle(handle);

if (error_code != DAPI_ERR_NONE)
{
printf(“Error detected on handle 0x%x – Error Code = 0x%x\n”, handle, error_code);

DapiClearLastErrorByHandle(handle);

return TRUE;
}

return FALSE;
}

DapiGetLastErrorText
Diese Funktion liest den Text des letzten erfassten Fehlers. Sofern ein Fehler aufgetreten ist, muss dieser mit DapiClearLastError() gelöscht werden, da sonst jeder Aufruf von DapiGetLastErrorText() den "alten" Fehler zurückgibt.

DapiGetLastErrorText

 

Beschreibung

Diese Funktion liest den Text des letzten erfassten Fehlers. Sofern ein Fehler aufgetreten ist, muss dieser mit DapiClearLastError() gelöscht werden, da sonst jeder Aufruf von DapiGetLastErrorText() den “alten” Fehler zurückgibt.

 

Definition

ULONG DapiGetLastErrorText(unsigned char * msg, unsigned long msg_length);

 

Parameter

msg = Buffer für den zu empfangenden Text
msg_length = Länge des Text Buffers

 

Programmierbeispiel

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

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

DapiClearLastError();

return TRUE;
}

return FALSE;
}

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

DapiClearLastError

Beschreibung

Diese Funktion löscht den letzten mit DapiGetLastError() registrierten Fehler.

 

Definition

void DapiGetLastError(void);

 

Parameter

Keine

 

Return Wert

Keine

 

Beispiel-Programm

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

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

DapiClearLastError();

return TRUE;
}

return FALSE;
}

DapiClearLastErrorByHandle
Diese Funktion löscht den letzten Fehler eines bestimmten Moduls (handle), der mit DapiGetLastErrorByHandle() erfasst wurde.

DapiClearLastErrorByHandle

 

Beschreibung

Diese Funktion löscht den letzten Fehler eines bestimmten Moduls (Handle), der mit DapiGetLastErrorByHandle() registriert wurde.

 

Definition

void DapiClearLastErrorByHandle(ULONG handle);

 

Parameter

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

 

Return Wert

Keine

 

Beispiel-Programm

BOOL IsError(ULONG handle)
{
unsigned long error_code = DapiGetLastErrorByHandle(handle);

if (error_code != DAPI_ERR_NONE)
{
printf(“Error detected on handle 0x%x – Error Code = 0x%x\n”, handle, error_code);

DapiClearLastErrorByHandle(handle);

return TRUE;
}

return FALSE;
}

DapiGetDELIBVersion
Diese Funktion gibt die installierte DELIB-Version zurück.

DapiGetDELIBVersion

 

Beschreibung

Diese Funktion gibt die installierte DELIB-Version zurück.

 

Definition

ULONG DapiGetDELIBVersion(ULONG mode, ULONG par);

 

Parameter

mode=Modus, mit dem die Version ausgelesen wird (muss immer 0 sein).
par=Dieser Parameter ist nicht definiert (muss immer 0 sein).

 

Return-Wert

version=Versionsnummer der installierten DELIB-Version [hex]

 

Programmierbeispiel

version = DapiGetDELIBVersion(0, 0);
//Bei installierter Version 1.32 ist version = 132(hex)

DapiOpenModuleEx
Diese Funktion öffnet gezielt ein Modul mit Ethernet-Schnittstelle. Dabei können die Parameter IP-Adresse, Portnummer und die Dauer des Timeouts bestimmt werden. Das Öffnen des Moduls geschieht dabei unabhängig von den im DELIB Configuration Utility getroffenen Einstellungen.

DapiOpenModuleEx

 

Beschreibung

Diese Funktion öffnet gezielt ein Modul mit Ethernet-Schnittstelle. Dabei können die Parameter IP-Adresse, Portnummer und die Dauer des Timeouts bestimmt werden.
Das Öffnen des Moduls geschieht dabei unabhängig von den im DELIB Configuration Utility getroffenen Einstellungen.

 

Definition

ULONG DapiOpenModuleEx(ULONG moduleID, ULONG nr, unsigned char* exbuffer, 0);

 

Parameter

moduleID = Gibt das Modul an, welches geöffnet werden soll (siehe delib.h)
nr = Gibt an, welches (bei mehreren Modulen) geöffnet werden soll.
nr = 0 -> 1. Modul
nr = 1 -> 2. Modul
exbuffer = Buffer für IP-Adresse, Portnummer und Dauer des Timeouts

 

Return-Wert

handle = Entsprechender Handle für das Modul
handle = 0 -> Modul wurde nicht gefunden

 

Bemerkung

Der von dieser Funktion zurückgegebene Handle wird zur Identifikation des Moduls für alle anderen Funktionen benötigt.
Dieser Befehl wird von allen Modulen mit Ethernet-Schnittstelle unterstützt.

 

Programmierbeispiel

// Open ETH-Module with parameter

DAPI_OPENMODULEEX_STRUCT open_buffer;

strcpy((char*) open_buffer.address, “192.168.1.10”);
open_buffer.portno = 0;
open_buffer.timeout = 5000;

handle = DapiOpenModuleEx(RO_ETH, 0, (unsigned char*) &open_buffer, 0);
printf(“Module handle = %x\n”, handle);

Digitale Eingabe-Funktionen

DapiDIGet1
Dieser Befehl liest einen einzelnen digitalen Eingang

DapiDIGet1

 

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

DapiDIGet8
Dieser Befehl liest gleichzeitig 8 digitale Eingänge

DapiDIGet8

 

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 must be 0, 8, 16, …

DapiDIGet16
Dieser Befehl liest gleichzeitig 16 digitale Eingänge

DapiDIGet16

 

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 must be 0, 16, 32, …

DapiDIGet32
Dieser Befehl liest gleichzeitig 32 digitale Eingänge

DapiDIGet32

 

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

DapiDIGet64
Dieser Befehl liest gleichzeitig 64 digitale Eingänge

DapiDIGet64

 

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 must be 0 or 64

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

DapiDIGetFF32

 

Beschreibung

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

 

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 must be 0, 32, 64, …

Digitale Eingabe-Counter

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

DapiDIGetCounter

 

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

 

Requirements

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

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

DapiSpecialCommand – DapiSpecialCounterLatchAll

 

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

 

Bemerkung

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

 

Programmierbeispiel

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

DapiSpecialCommand - DapiSpecialCounterLatchAllWithReset
Dieser Befehl speichert die Zählerstände aller Eingangszähler gleichzeitig in ein Zwischenspeicher (Latch). Zusätzlich werden die Zählerstände der Eingangszähler im Anschluß resettet.

DapiSpecialCommand – DapiSpecialCounterLatchAllWithReset

 

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 Anschluß resettet.

 

Definition

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

 

Parameter

 

Bemerkung

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

 

Programmierbeispiel

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

Digitale Ausgabe-Funktionen

DapiDOSet1
Dieser Befehl setzt einen einzelnen Ausgang.

DapiDOSet1

 

Beschreibung

Dieser Befehl setzt einen einzelnen Ausgang.

 

Definition

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

 

Parameter

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

 

Return-Wert

Keiner

 

Anforderungen

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

 

DAPI_SW_FEATURE_BIT_CFG_DO

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

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

DapiDOSet8
Dieser Befehl setzt gleichzeitig 8 digitale Ausgänge.

DapiDOSet8

 

Beschreibung

Dieser Befehl setzt gleichzeitig 8 digitale Ausgänge.

 

Definition

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

 

Parameter

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

 

Return-Wert

Keiner

DapiDOSet16
Dieser Befehl setzt gleichzeitig 16 digitale Ausgänge.

DapiDOSet16

 

Beschreibung

Dieser Befehl setzt gleichzeitig 16 digitale Ausgänge.

 

Definition

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

 

Parameter

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

 

Return-Wert

Keiner

DapiDOSet32
Dieser Befehl setzt gleichzeitig 32 digitale Ausgänge.

DapiDOSet32

 

Beschreibung

Dieser Befehl setzt gleichzeitig 32 digitale Ausgänge.

 

Definition

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

 

Parameter

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

 

Return-Wert

Keiner

 

Programmierbeispiel

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

DapiDOSet64
Dieser Befehl setzt gleichzeitig 64 digitale Ausgänge.

DapiDOSet64

 

Beschreibung

Dieser Befehl setzt gleichzeitig 64 digitale Ausgänge.

 

Definition

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

 

Parameter

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

 

Return-Wert

Keiner

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

DapiDOClrBit32

 

Beschreibung

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

 

Definition

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

 

Parameter

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

 

Return-Wert

Keiner

 

Bemerkung

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

 

Programmierbeispiel

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

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

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

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

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

DapiDOSet1_WithTimer

 

Beschreibung

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

 

Definition

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

 

Parameter

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

 

Return-Wert

Keiner

 

Bemerkung

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

 

Programmierbeispiel

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

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

DapiDOSetBit32

 

Beschreibung

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

 

Definition

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

 

Parameter

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

 

Return-Wert

Keiner

 

Bemerkung

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

 

Programmierbeispiel

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

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

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

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

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

DapiDOReadback32

 

Beschreibung

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

 

Definition

ULONG DapiDOReadback32(ULONG handle, ULONG ch);

 

Parameter

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

 

Return-Wert

Zustand von 32 Ausgängen.

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

DapiDOReadback32

 

Beschreibung

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

 

Definition

ULONG DapiDOReadback32(ULONG handle, ULONG ch);

 

Parameter

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

 

Return-Wert

Zustand von 32 Ausgängen.

Analoge Eingabe-Funktionen

DapiADSetMode
Dieser Befehl konfiguriert den Spannungsbereich für einen A/D Wandler.

DapiADSetMode

 

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

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

DapiADGetMode

 

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

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

DapiADGet

 

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

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

DapiADGetVolt

 

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

DapiADGetmA
Dieser Befehl liest einen Datenwert von einen Kanal eines A/D Wandlers in mA.

DapiADGetmA

 

Beschreibung

Dieser Befehl liest einen Datenwert von einen Kanal 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 Modul abhängig. Er funktioniert natürlich nur, wenn das Modul auch den Strom-Modus unterstützt.

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

DapiSpecialCommand – DapiReadMultipleBytes

 

Beschreibung

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

 

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 DapiReadMultipleBytes 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 AD-Kanal 0..15

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

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

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

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

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

Analoge Ausgabe-Funktionen

DapiDASetMode
Dieser Befehl setzt den Modus für einen D/A Wandler.

DapiDASetMode

 

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

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

DapiDAGetMode

 

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

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

DapiDASet

 

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

 

Return-Wert

Keiner

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

DapiDASetVolt

 

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

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

DapiDASetmA

 

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 Modul abhängig. Er funktioniert natürlich nur, wenn das Modul auch den Strom-Modus unterstützt.

Analoge Temperatur-Funktionen

DapiTempGet
Dieser Befehl liest einen Temperatur Kanal.

DapiTempGet

 

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

PWM-Funktionen

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

DapiPWMOutReadback

 

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

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

DapiPWMOutSet

 

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)

DapiSpecialCommand - DAPI_SPECIAL_PWM_FREQ_SET
Dieser Befehl setzt die PWM Frequenz des Moduls

DapiSpecialCommand – DAPI_SPECIAL_PWM_FREQ_SET

 

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

DapiSpecialCommand - DAPI_SPECIAL_PWM_FREQ_READBACK
Dieser Befehl liest die aktuelle PWM Frequenz des Moduls

DapiSpecialCommand – DAPI_SPECIAL_PWM_FREQ_READBACK

 

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

TTL-Funktionen

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

DapiSpecialCommand – DapiSpecialCMDSetDirDX_1

 

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

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

DapiSpecialCommand – DapiSpecialCMDSetDirDX_8

 

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

Timeout-Schutz-Funktion

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

DapiSpecialCommand-DapiSpecialCMDTimeout

 

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

 

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

 

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

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

DapiSpecialCommand – DapiSpecialTimeoutSetValueSec

 

Beschreibung
Dieser Befehl dient zum Setzen der Timeout-Zeit.

 

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

 

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

 

Bemerkung

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

 

Programmierbeispiel

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

DapiSpecialCommand - DapiSpecialTimeoutActivate
Dieser Befehl aktiviert den Timeout

DapiSpecialCommand – DapiSpecialTimeoutActivate

 

Beschreibung

Dieser Befehl aktiviert den Timeout.

 

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 Timeout wird aktiviert.

DapiSpecialCommand - DapiSpecialTimeoutDeactivate
Dieser Befehl deaktiviert den Timeout

DapiSpecialCommand – DapiSpecialTimeoutDeactivate

 

Beschreibung

Dieser Befehl deaktiviert den Timeout.

 

Definition

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

 

Parameter

cmd = DAPI_SPECIAL_TIMEOUT_DEACTIVATE

 

Programmierbeispiel

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

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

DapiSpecialCommand – DapiSpecialTimeoutGetStatus

 

Beschreibung

Dieser Befehl dient zum Auslesen des Timeout-Status.

 

Definition

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

 

Parameter

cmd = DAPI_SPECIAL_TIMEOUT_GET_STATUS

 

Return-Wert

Return = 0 (Timeout ist deaktiviert)
Return = 1 (Timeout ist aktiviert)
Return = 2 (Timeout hat stattgefunden)

 

Programmierbeispiel

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

DapiSpecialCommand - DapiSpecialTimeoutDoValueMaskWRSet32
Dieser Befehl aktiviert Relais bei einem Timeout

DapiSpecialCommand – DapiSpecialTimeoutDoValueMaskWRSet32

 

Beschreibung

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

 

Definition

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

 

Parameter

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

 

Programmierbeispiel

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

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

DapiSpecialCommand – DapiSpecialTimeoutDoValueMaskRDSet32

 

Beschreibung

Dieser Befehl dient zum Auslesen der übergebenen Werte

 

Definition

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

 

Parameter

cmd = DAPI_SPECIAL_TIMEOUT_DO_VALUE_MASK_RD_SET32

 

Return-Wert

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

 

Programmierbeispiel

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

DapiSpecialCommand - DapiSpecialTimeoutDoValueMaskWRClr32
Dieser Befehl deaktiviert Relais bei einem Timeout

DapiSpecialCommand – DapiSpecialTimeoutDoValueMaskWRClr32

 

Beschreibung

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

 

Definition

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

 

Parameter

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

 

Programmierbeispiel

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

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

DapiSpecialCommand – DapiSpecialTimeoutDoValueMaskRDClr32

 

Beschreibung

Dieser Befehl dient zum Auslesen der übergebenen Werte.

 

Definition

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

 

Parameter

cmd = DAPI_SPECIAL_TIMEOUT_DO_VALUE_MASK_RD_CLR32

 

Return-Wert

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

 

Programmierbeispiel

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

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

DapiSpecialCommand – DapiSpecialTimeoutDoValueLoadDefault

 

Beschreibung

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

 

Definition

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

 

Parameter

cmd = DAPI_SPECIAL_TIMEOUT_DO_VALUE_LOAD_DEFAULT

 

Programmierbeispiel

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

Watchdog-Funktionen

DapiWatchdogEnable
Diese Funktion aktiviert den Watchdog.

DapiWatchdogEnable

 

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

DapiWatchdogDisable
Diese Funktion deaktiviert den Watchdog.

DapiWatchdogDisable

 

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

DapiWatchdogRetrigger
Diese Funktion retriggert den Watchdog-Timer.

DapiWatchdogRetrigger

 

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

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

Watchdog-Special

 

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

Stepper Motor-Funktionen

DapiStepperCommandEx
Dieser erweiterte Befehl steuert Schrittmotoren an.

DapiStepperCommandEx

 

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.

DapiStepperCommand - DapiStepperCMDStop
Dieses Kommando dient zum Anhalten des Motors, die Bremsrampe wird dabei eingehalten.

DapiStepperCommand – DapiStepperCmdStop

 

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

 

Parameter

 

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

DapiStepperCommand – DapiStepperCommand_GoPosition

 

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

DapiStepperCommand - DapiStepperCommand_GoPosition_Relative
Hiermit wird eine relative Position angefahren. Im Gegensatz zum Befehl GO_POSITION, der eine absolute Position anfährt, wird hier die momentane Position berücksichtigt. Dieses Kommando darf nur ausgeführt werden, wenn der Motor nicht "disabled" ist und kein Go_Position oder Go_Referenz ausgeführt wird.

DapiStepperCommand – DapiStepperCommand_GoPosition_Relative

 

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.

DapiStepperCommand - DapiStepperCommand_GoRefswitch
Der Motor fährt zur Referenzposition

DapiStepperCommand – DapiStepperCommand_GoRefswitch

 

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

DapiStepperCommand - DapiStepperCommand_Fullstop
Dieses Kommando dient zum sofortigen Anhalten des Motors, die Bremsrampe wird dabei nicht eingehalten. Die Motorposition kann vielleicht danach nicht mehr stimmen, da der Motor unkontrolliert angehalten wird.

DapiStepperCommand – DapiStepperCommand_Fullstop

 

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

 

Parameter

 

Programmierbeispiel

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

DapiStepperCommand - DapiStepperCommand_Disable
Dieses Kommando dient zum disablen/enabeln des Motors, der Motor verfährt dann nicht mehr/oder wieder. Dieses Kommando darf nur bei Motorstillstand benutzt werden.

DapiStepperCommand – DapiStepperCommand_Disable

 

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)

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

DapiStepperCommand – DapiStepperCommand_SetPosition

 

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

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

DapiStepperCommand – DapiStepperCommand_SetFrequency

 

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]

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

DapiStepperCommand – DapiStepperCommand_SetFrequencyDirectly

 

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]

DapiStepperCommand - DapiStepperCommand_GetFrequency
Dieses Kommando dient zum Abfragen der Motorfrequenz. Dieses Kommando darf immer verwendet werden.

DapiStepperCommand – DapiStepperCommand_GetFrequency

 

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

 

Parameter

 

Return-Wert

Motorfrequenz [Hz]

DapiStepperCommand - DapiStepperCommand_SetMotorcharacteristic
Hiermit werden neue Motor Konfigurationen gesetzt

DapiStepperCommand – DapiStepperCommand_SetMotorcharacteristic

 

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.

DapiStepperCommand - DapiStepperCommand_GetMotorcharacteristic
Hiermit wird der Motorspezifische Parameter ausgelesen. Dieses Kommando darf immer benutzt werden. Es teilt sich in Unterkommandos auf, die analog den Parametern von DAPI_STEPPER_CMD_SET_MOTORCHARACTERISTIC sind.

DapiStepperCommand – DapiStepperCommand_GetMotorcharacteristic

 

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.

DapiStepperCommand - DapiStepperCommand_MotorcharacteristicLoadDefault
Es wird die Motorcharakteristik des Motors auf Defaultwerte zurück gesetzt.

DapiStepperCommand – DapiStepperCommand_MotorcharacteristicLoadDefault

 

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

 

Parameter

 

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

DapiStepperCommand - DapiStepperCommand_Motorcharacteristic_EEPROMSave
Es wird die aktuelle Motorcharakteristik des Motors ins EEPROM abgespeichert.

DapiStepperCommand – DapiStepperCommand_MotorcharacteristicEEPROMSave

 

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

 

Parameter

DapiStepperCommand - DapiStepperCommand_Motorcharacteristic_EEPROMSLoad
Es wird die Motorcharakteristik des Motors aus dem EEPROM geladen.

DapiStepperCommand – DapiStepperCommand_MotorcharacteristicEEPROMLoad

 

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

 

Parameter

DapiStepperCommand - DapiStepperCommand_GetCPUTemp
Die Temperatur des CPU wird abgefragt.

DapiStepperCommand – DapiStepperCommand_GetCPUTemp

 

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]

DapiStepperCommand - DapiStepperCommand_GetMotorSupplyVoltage
Hiermit wird die Versorgungsspannung des Motors abgefragt.

DapiStepperCommand – DapiStepperCommand_GetMotorSupplyVoltage

 

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]

DapiStepperCommand - DapiStepperCommand_GetPosition
Hiermit wird eine bestimmte Position abgelesen

DapiStepperGetStatus – DapiStepperGetStatus_GetPosition

 

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

DapiStepperCommand - DapiStepperCommand_GetSwitch
Hiermit wird der Zustand der Schalter abgefragt

DapiStepperGetStatus – DapiStepperGetStatus_GetSwitch

 

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

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

DapiStepperGetStatus – DapiStepperGetStatus_GetActivity

 

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

Software FIFO-Funktionen

DapiSpecialCommand - DapiSpecialCMDSWFifo
Dieser Befehl dient zum Einstellen der Software FIFO der NET-Serie

DapiSpecialCommand-DapiSpecialCMDSWFifo

 

Beschreibung

Dieser Befehl dient zum Einstellen der Software FIFO.
DAPI_SPECIAL_CMD_SW_FIFO-Befehle funktionieren nur bei der NET-Serie.

 

Definition

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

 

Parameter

handle = Dies ist das Handle eines geöffneten Moduls
cmd = auszuführende Funktion
fifo_instance = Gibt die Instanz des Software FIFO an. Bislang gibt es nur Instanz 0
par2 = Wert, der an die Funktion übergeben wird

 

Bemerkung

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

DapiSpecialCommand - DapiSpecialSWFifoSetSubmodule
Dieser Befehl gibt an, an welches Submodul die Daten des Software FIFO übergeben werden

DapiSpecialCommand-DapiSpecialSWFifoSetSubmodule

 

Beschreibung

Dieser Befehl gibt an, an welches Submodul die Daten des Software FIFO übergeben werden.

 

Definition

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

 

Parameter

cmd = DAPI_SPECIAL_SW_FIFO_SET_SUBMODULE
fifo_instance = Gibt die Instanz des Software FIFO an
par2 = gibt die Nummer des Submoduls an (0, 1, 2, 3, …)

 

Programmierbeispiel

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_SET_SUBMODULE, fifo_instance, 2);
//Der Software FIFO überträgt die Daten an Submodul 2.

DapiSpecialCommand - DapiSpecialSWFifoGetSubmodule
Dieser Befehl gibt die Nummer des Submoduls, auf welches die Daten übertragen werden, wieder

DapiSpecialCommand-DapiSpecialSWFifoGetSubmodule

 

Beschreibung

Dieser Befehl gibt die Nummer des Submoduls, auf welches die Daten übertragen werden, wieder.

 

Definition

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

 

Parameter

cmd = DAPI_SPECIAL_SW_FIFO_GET_SUBMODULE
fifo_instance = Gibt die Instanz des Software FIFO an

 

Return-Wert

Nummer des Submodules (0, 1, 2, 3, …)

 

Programmierbeispiel

unsigned long ret = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_GET_SUBMODULE, fifo_instance, 0);
printf(“Submodule = %lu\n”, ret);
//Die Nummer des Submoduls wird ausgelesen und dargestellt.

DapiSpecialCommand - DapiSpecialSWFifoActivate
Dieser Befehl aktiviert die automatische Ausgabe des D/A Wandlers

DapiSpecialCommand-DapiSpecialSWFifoActivate

 

Beschreibung

Dieser Befehl aktiviert die Fifo-Datenübertragung innerhalb der NET-Module.

 

Definition

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

 

Parameter

cmd = DAPI_SPECIAL_SW_FIFO_ACTIVATE
fifo_instance = Gibt die Instanz des Software FIFO an

 

Programmierbeispiel

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_ACTIVATE, fifo_instance, 0);
//Das automatische Ausgeben des D/A Wandlers wird aktiviert.

DapiSpecialCommand - DapiSpecialSWFifoDeactivate
Dieser Befehl deaktiviert die automatische Ausgabe des D/A Wandlers

DapiSpecialCommand-DapiSpecialSWFifoDeactivate

 

Beschreibung

Dieser Befehl deaktiviert die Fifo-Datenübertragung innerhalb der NET-Module.

 

Definition

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

 

Parameter

cmd = DAPI_SPECIAL_SW_FIFO_DEACTIVATE
fifo_instance = Gibt die Instanz des Software FIFO an

 

Programmierbeispiel

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_DEACTIVATE, fifo_instance, 0);
//Das automatische Ausgeben des D/A Wandlers wird deaktiviert.

DapiSpecialCommand - DapiSpecialSWFifoGetActivity
Mit diesem Befehl wird der Status der Übertragung des FIFO an den D/A Wandler abgerufen (ob aktiv oder inaktiv)

DapiSpecialCommand-DapiSpecialSWFifoGetActivity

 

Beschreibung

Mit diesem Befehl wird der Status der Übertragung des FIFO an den D/A Wandler abgerufen (ob aktiv oder inaktiv).

 

Definition

ULONG DapiSpecialCommand(handle, DAPI_SPECIAL_SW_FIFO, cmd, fifo_instance, 0);

 

Parameter

cmd = DAPI_SPECIAL_SW_FIFO_GET_ACTIVITY
fifo_instance = Gibt die Instanz des Software FIFO an

 

Return-Wert

Return = 0 (Übertragung ist deaktiviert)
Return = 1 (Übertragung ist aktiviert)

 

Programmierbeispiel

unsigned long ret = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_GET_ACTIVITY, fifo_instance, 0);
printf(“Status = %lu\n”, ret);
//Übertragungs-Status wird abgerufen

DapiSpecialCommand - DapiSpecialSWFifoIOActivate
Dieser Befehl aktiviert die FIFO- I/O Ein-/Ausgabe

DapiSpecialCommand-DapiSpecialSWFifoIOActivate

 

Beschreibung

Dieser Befehl aktiviert die FIFO- I/O Ein-/Ausgabe.

 

Definition

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

 

Parameter

cmd = DAPI_SPECIAL_SW_FIFO_IO_ACTIVATE
fifo_instance = Gibt die Instanz des Software FIFO an

 

Programmierbeispiel

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

DapiSpecialCommand - DapiSpecialSWFifoIODeactivate
Dieser Befehl deaktiviert die FIFO- I/O Ein-/Ausgabe

DapiSpecialCommand-DapiSpecialSWFifoIODeactivate

 

Beschreibung

Dieser Befehl deaktiviert die FIFO- I/O Ein-/Ausgabe.

 

Definition

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

 

Parameter

cmd = DAPI_SPECIAL_SW_FIFO_IO_DEACTIVATE
fifo_instance = Gibt die Instanz des Software FIFO an

Programmierbeispiel

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

DapiSpecialCommand - DapiSpecialSWFifoInitAndClear
Dieser Befehl löscht vorhandene Daten aus dem Software FIFO Speicher und bringt den FIFO-Mechanismus in den Ausgangszustand zurück

DapiSpecialCommand-DapiSpecialSWFifoInitAndClear

 

Beschreibung

Dieser Befehl löscht vorhandene Daten aus dem Software FIFO Speicher und bringt den FIFO-Mechanismus in den Ausgangszustand zurück.

 

Definition

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

 

Parameter

cmd = DAPI_SPECIAL_SW_FIFO_INIT_AND_CLEAR
fifo_instance = Gibt die Instanz des Software FIFO an

 

Programmierbeispiel

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_INIT_AND_CLEAR, fifo_instance, 0);
//Vorhandene Daten werden aus dem FIFO Speicher gelöscht.

DapiSpecialCommand - DapiSpecialSWFifoSetChannel
Dieser Befehl gibt unter Angabe von Start- und Endkanal an, in welche A/D Kanäle die Daten des FIFO übertragen werden sollen

DapiSpecialCommand-DapiSpecialSWFifoSetChannel

 

Beschreibung

Dieser Befehl gibt unter Angabe von Start- und Endkanal an, in welche A/D Kanäle die Daten des FIFO übertragen werden sollen.

 

Definition

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO, cmd, fifo_instance, ch);

 

Parameter

cmd = DAPI_SPECIAL_SW_FIFO_SET_CHANNEL
fifo_instance = Gibt die Instanz des Software FIFO an
ch = Angabe des Start- und Endkanals

 

Programmierbeispiel

unsigned long ch_start = 0; //Start with D/A Channel 0
unsigned long ch_end = 1; //End with D/A Channel 1

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_SET_Channel, fifo_instance,
((ch_end << 8) & 0xff00) | (ch_start & 0xff);
//Der Start- und Endkanal wird festgelegt

DapiSpecialCommand - DapiSpecialSWFifoGetChannel
Dieser Befehl zeigt die D/A Kanäle auf welches die Daten übertragen werden

DapiSpecialCommand-DapiSpecialSWFifoGetChannel

 

Beschreibung

Dieser Befehl zeigt die D/A Kanäle auf welches die Daten übertragen werden.

 

Definition

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

 

Parameter

cmd = DAPI_SPECIAL_SW_FIFO_GET_CHANNEL
fifo_instance = Gibt die Instanz des Software FIFO an

 

Return-Wert

Nummer der A/D Kanäle
Bit 0-7 Startkanal
Bit 8-15 Endkanal

 

Programmierbeispiel

unsigned long ret = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_GET_CHANNEL, fifo_instance, 0);
printf(“Channel = %lu\n”, ret);
//Zeigt auf welche A/D Kanäle die Daten übertragen werden.

DapiSpecialCommand - DapiSpecialSWFifoSetFrequencyHz
Dieser Befehl gibt an, in welchem Frequenzintervall (in Hertz) aus dem FIFO in das Modul geschrieben wird

DapiSpecialCommand-DapiSpecialSWFifoSetFrequencyHz

 

Beschreibung

Dieser Befehl gibt an, in welchem Frequenzintervall (in Hertz) aus dem FIFO in das Modul geschrieben wird.

 

Definition

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

 

Parameter

cmd = DAPI_SPECIAL_SW_FIFO_SET_FREQUENCY_HZ
fifo_instance = Gibt die Instanz des Software FIFO an
par2 = Frequenzintervall in Hertz (Hz)

 

Programmierbeispiel

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

DapiSpecialCommand - DapiSpecialSWFifoGetFrequencyHz
Dieser Befehl gibt das vorher eingestellte Frequenzintervall in Hertz wieder

DapiSpecialCommand-DapiSpecialSWFifoGetFrequencyHz

 

Beschreibung

Dieser Befehl gibt das vorher eingestellte Frequenzintervall in Hertz wieder.

 

Definition

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

 

Parameter

cmd = DAPI_SPECIAL_SW_FIFO_GET_FREQUENCY_HZ
fifo_instance = Gibt die Instanz des Software FIFO an

 

Return-Wert

Frequenzintervall in Hertz (Hz)

 

Programmierbeispiel

unsigned long ret = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_GET_FREQUENCY_HZ, fifo_instance, 0);
printf(“Frequency = %lu (Hz)\n”, ret);
//Zeigt das vorher eingestellte Frequenzintervall an.

DapiSpecialCommand - DapiSpecialSWFifoGetBytesFree
Dieser Befehl dient zum Auslesen der freien Bytes im Software FIFO Buffer

DapiSpecialCommand-DapiSpecialSWFifoGetBytesFree

 

Beschreibung

Dieser Befehl dient zum Auslesen der freien Bytes im Software FIFO Buffer.

 

Definition

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

 

Parameter

cmd = DAPI_SPECIAL_SW_FIFO_GET_BYTES_FREE
fifo_instance = Gibt die Instanz des Software FIFO an

 

Return-Wert

Freie Bytes des Software FIFO

 

Programmierbeispiel

unsigned long ret = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_GET_BYTES_FREE, fifo_instance, 0);
printf(“Freier Speicher = %lu\n”, ret);
//Ausgabe der noch freien Bytes des Speichers.

DapiSpecialCommand - DapiSpecialSWFifoGetBytesPerSample
Dieser Befehl gibt an wieviel Bytes für das Schreiben in den D/A Wandler notwendig sind

DapiSpecialCommand-DapiSpecialSWFifoGetBytesPerSample

 

Beschreibung

Dieser Befehl gibt an wieviel Bytes für das Schreiben in den D/A Wandler notwendig sind.
Beispiel: Werden bei einem 16 Bit (2Byte) D/A Wandler 3 D/A Kanäle beschrieben, werden also 3×2 Bytes pro Sample benötigt. Der Wert 6 wird wiedergeben.

 

Definition

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

 

Parameter

cmd = DAPI_SPECIAL_SW_FIFO_GET_BYTES_PER_SAMPLE
fifo_instance = Gibt die Instanz des Software FIFO an

 

Return-Wert

Benötigte Bytes pro Sample

 

Programmierbeispiel

unsigned long ret = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_GET_BYTES_PER_SAMPLE, fifo_instance, 0);
printf(“Benoetigte Bytes = %lu\n”, ret);
//Ausgabe der notwendigen Bytes pro Sample.

DapiSpecialCommand - DapiSpecialSWFifoSetMode
Dieser Befehl setzt den Software FIFO Mode

DapiSpecialCommand-DapiSpecialSWFifoSetMode

 

Beschreibung

Dieser Befehl setzt den Software FIFO Mode. In der aktuellen Firmware wird dieser Befehl noch nicht unterstützt.

 

Definition

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

 

Parameter

cmd = DAPI_SPECIAL_SW_FIFO_SET_MODE
fifo_instance = Gibt die Instanz des Software FIFO an
par2 = Software FIFO Mode

 

Programmierbeispiel

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

DapiSpecialCommand - DapiSpecialSWFifoGetMode
Dieser Befehl gibt den vorher eingestellten FIFO Mode wieder

DapiSpecialCommand-DapiSpecialSWFifoGetMode

 

Beschreibung

Dieser Befehl gibt den vorher eingestellten FIFO Mode wieder. Aktuell wird dieser in der Firmware noch nicht unterstützt.

 

Definition

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

 

Parameter

cmd = DAPI_SPECIAL_SW_FIFO_GET_MODE
fifo_instance = Gibt die Instanz des Software FIFO an

 

Return-Wert

FIFO Software Mode

 

Programmierbeispiel

unsigned long ret = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO,
DAPI_SPECIAL_SW_FIFO_GET_MODE, fifo_instance, 0);
printf(“Mode = %lu\n”, ret);
//Gibt den vorher eingestellten FIFO Mode wieder.

DapiSpecialCommand - DapiSpecialSWFifoGetStatus
Mit diesem Befehl werden Status Informationen abgerufen. In der Aktuellen Firmware wird dies noch nicht unterstützt

DapiSpecialCommand-DapiSpecialSWFifoGetStatus

 

Beschreibung

Mit diesem Befehl können Statuswerte abgerufen werden.

 

Definition

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

 

Parameter

cmd = DAPI_SPECIAL_SW_FIFO_GET_STATUS
fifo_instance = Gibt die Instanz des Software FIFO an

 

Return-Wert

Beschreibung
(FIFO-Status erzeugt einen Return-Wert…)
Return-Wert in hex
DAPI_SPECIAL_SW_FIFO_STATUS_IS_ACTIVE … wenn die Ausgabe des D/A Wandlers aktiv ist 0x01
DAPI_SPECIAL_SW_FIFO_STATUS_IO_IS_ACTIVE … wenn die Ausgabe des FIFO I/O aktiv ist 0x02
DAPI_SPECIAL_SW_FIFO_STATUS_FIFO_OVERFLOW … wenn zuviele Daten in den FIFO geschrieben werden 0x04
DAPI_SPECIAL_SW_FIFO_STATUS_FIFO_UNDERRUN … wenn der FIFO leer läuft 0x08
DAPI_SPECIAL_SW_FIFO_STATUS_FIFO_OUT_OF_SYNC … wenn die FIFO-Kommunikation innerhalb der Module unterbrochen ist 0x10

Programmierbeispiel

unsigned long ret;

ret = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SW_FIFO,DAPI_SPECIAL_SW_FIFO_GET_STATUS, fifo_instance, 0);
if((ret & 0x01) != 0) {printf(“is_active”);}
if((ret & 0x02) != 0) {printf(“io_is_active”);}
if((ret & 0x04) != 0) {printf(“fifo_overflow”);}
if((ret & 0x08) != 0) {printf(“fifo_underrun”);}
if((ret & 0x10) != 0) {printf(“fifo_out_of_sync);}

DapiSpecialCommand - DapiSpecialCMDAD
Dieser Befehl verwaltet die Steuerung des Software-FIFO eines A/D-Wandlers

DapiSpecialCommand-DapiSpecialCMDAD

 

Beschreibung

Dieser Befehl verwaltet die Steuerung des Software-FIFO eines A/D-Wandlers.

 

Definition

ULONG DapiSpecialCommand(ULONG handle, DAPI_SPECIAL_CMD_AD, ULONG cmd, ULONG ch_range, ULONG par0);

 

Parameter

handle = Dies ist das Handle eines geöffneten Moduls
ch_range = Gibt die Nummer des A/D-Wandler Moduls an (siehe Beispiel bzw. Datei delib.h)

 

FIFO initialisieren

cmd=DAPI_SPECIAL_RO_AD_FIFO_INIT
par0=nicht definiert

FIFO aktivieren
cmd=DAPI_SPECIAL_RO_AD_FIFO_ACTIVATE
par0=nicht definiert

FIFO deaktivieren
cmd=DAPI_SPECIAL_RO_AD_FIFO_DEACTIVATE
par0=nicht definiert

FIFO Interval setzen
cmd=DAPI_SPECIAL_RO_AD_FIFO_SET_INTERVAL_MS
par0=Intervall [msec]

FIFO für einen A/D-Wandler Kanal setzen
cmd=DAPI_SPECIAL_RO_AD_FIFO_SET_CHANNEL
par0=16 Bit Wert für A/D-Kanäle, die in den FIFO geschrieben werden. Jedes Bit steht für einen Kanal (Bit0 -> AD0, Bit1 -> AD1, .. Bit15 -> AD15).
Ist das Bit gesetzt, ist der entsprechende A/D-Kanal aktiv.

FIFO Status abfragen
cmd=DAPI_SPECIAL_RO_AD_FIFO_GET_STATUS
par0=nicht definiert

 

Return-Wert

cmd=DAPI_SPECIAL_RO_AD_FIFO_INIT
kein return Wert

cmd=DAPI_SPECIAL_RO_AD_FIFO_ACTIVATE
kein return Wert

cmd=DAPI_SPECIAL_RO_AD_FIFO_DEACTIVATE
kein return Wert

cmd=DAPI_SPECIAL_RO_AD_FIFO_SET_INTERVAL_MS
kein return Wert

cmd=DAPI_SPECIAL_RO_AD_FIFO_SET_CHANNEL
kein return Wert

cmd=DAPI_SPECIAL_RO_AD_FIFO_GET_STATUS
return=aktueller FIFO-Status

Wert [hex] Bedeutung Erklärung 0x80 RO_FIFO_STATUS_MASK_MEASURE_ENABLED FIFO ist aktiv 0x40 RO_FIFO_STATUS_MASK_TEST_DATA
0x20 RO_FIFO_STATUS_MASK_OVERFLOW FIFO Buffer ist voll 0x10 RO_FIFO_STATUS_MASK_UNDERRUN
0x08 RO_FIFO_STATUS_FULL_256_BYTE 256 Byte Daten vorhanden 0x04 RO_FIFO_STATUS_FULL_64_BYTE 64 Byte Daten vorhanden 0x02 RO_FIFO_STATUS_FULL_16_BYTE 16 Byte Daten vorhanden 0x01 RO_FIFO_STATUS_FULL_1_BYTE 1 Byte Daten vorhanden

 

Programmierbeispiel

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_AD, DAPI_SPECIAL_RO_AD_FIFO_DEACTIVATE, DAPI_SPECIAL_AD_CH0_CH15, 0);
// deactivates the current AD-FIFO recording for AD module0 (channel 0 to 15)

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_AD, DAPI_SPECIAL_RO_AD_FIFO_INIT, DAPI_SPECIAL_AD_CH0_CH15, 0);
// initialze a new AD-FIFO recording for AD module 0 (channel 0 to 15)

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_AD, DAPI_SPECIAL_RO_AD_FIFO_SET_INTERVAL_MS, DAPI_SPECIAL_AD_CH0_CH15, 100);
// set the AD-FIFO interval for recording to 100ms fir AD module 0 (channel 0 to 15)

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_AD, DAPI_SPECIAL_RO_AD_FIFO_SET_CHANNEL, DAPI_SPECIAL_AD_CH0_CH15, 0x1051);
// set the A/D channels which should be recorded for AD module 0 (channel 0 to 15)
// 0x1051 [hex] = 0001 0000 0101 0001 [bin]
// the following channels will be recorded: AD0, AD4, AD6 and AD12

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_AD, DAPI_SPECIAL_RO_AD_FIFO_ACTIVATE, DAPI_SPECIAL_AD_CH0_CH15, 0);
// starts / activates the recording

status = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_AD, DAPI_SPECIAL_RO_AD_FIFO_GET_STATUS, DAPI_SPECIAL_AD_CH0_CH15, 0);
// get the current AD-FIFO status

DapiWriteFifo
Dieser Befehl schreibt Datensätze in den Software FIFO

DapiWriteFifo

 

Beschreibung

Dieser Befehl schreibt Datensätze in den Software FIFO.

 

Definition

DapiWriteFifo(ULONG handle, ULONG fifo_instance, ULONG type, UCHAR * buffer, ULONG buffer_length);

 

Parameter

handle=Dies ist das Handle eines geöffneten Moduls
fifo_instance=Gibt die Instanz des Software FIFO an
type=Gibt den FIFO-Typ an
buffer=Buffer für den zu sendenden Datensatz
buffer_length=Länge des Buffers

 

Programmierbeispiel

DapiWriteFifo(handle, fifo_instance, 0, buff, pos);
//Schreibt den Datensatz in den Software FIFO.

DapiReadFifo
Dieser Befehl liest den Software-FIFO von RO-Modulen aus

DapiReadFifo

 

Beschreibung

Dieser Befehl liest den Software-FIFO aus. Die ausgelesenen Datensätze werden nach dem Lesen aus dem Software-FIFO des Moduls gelöscht.

 

Definition

ULONG DapiReadFifo(ULONG handle, ULONG fifo_instance, ULONG type, UCHAR * buffer, ULONG buffer_length);

 

Parameter

handle=Dies ist das Handle eines geöffneten Moduls
fifo_instance=Gibt die Instanz des Software FIFO an
type=Gibt den FIFO-Typ an
buffer=Buffer für den zu empfangenden Datensatz
buffer_length=Länge des Buffers

 

Return-Wert

Länge der ausgelesenen FIFO-Datenstätze

 

Aufbau eines FIFO-Datensatz

(Beispiel mit 2 aktiven AD Kanälen, AD0 und AD4)

Byte || Bedeutung || Wert [hex]

0 RO_FIFO_ID_START 0xf0

1 FIFO-Typ
2 Zeitstempel (Bit0..Bit7)
3 Zeitstempel (Bit8..Bit15)
4 Aktive A/D-Kanäle (Bit0..Bit7) 0x11

5 Aktive A/D-Kanäle (Bit8..Bit15) 0x00

6 A/D Wert Kanal 0 (Bit0..Bit7)
7 A/D Wert Kanal 0 (Bit8..Bit15)
8 A/D Wert Kanal 4 (Bit0..Bit7)
9 A/D Wert Kanal 4 (Bit8..Bit15)
10 RO_FIFO_ID_END 0xf1

FIFO-Datenstatz = 7 Bytes ID + (2 x Anzahl aktiver A/D-Kanäle) Bytes Daten

 

RO_FIFO_ID_START

Signalisiert den Anfang eines neuen FIFO-Datensatzes. Die RO_FIFO_ID_START hat immer den Wert 0xf0 [hex]

 

FIFO Typ

Gibt den FIFO Typ an (z.B. RO_FIFO_ID_TYPE_AD16M0 für A/D-FIFO)

 

Zeitstempel

Gibt den 16 Bit Zeitstempel des aktuellen Datensatzes an. Zeit-Referenz ist hierbei der Zeitpunkt der Aktivierung des FIFO.
Beim Überlauf des Zeitstempels, wird dieser auf 0 zurückgesetzt.

 

Aktive A/D-Kanäle

Gibt einen 16 Bit Wert für die aktuell aktiven A/D-Kanäle an. Jedes Bit steht für einen Kanal (Bit0 -> AD0, Bit1 -> AD1, .. Bit15 -> AD15).
Ist das Bit gesetzt, ist der entsprechende A/D-Kanal aktiv

RO_FIFO_ID_END
Signalisiert das Ende eines FIFO-Datensatzes. Die RO_FIFO_ID_END hat immer den Wert 0xf1 [hex]

 

Bemerkung

Dieser Befehl wird nur von unseren Modulen der RO-ETH-Serie unterstützt.
Beachten Sie, dass der Software FIFO zuvor mit dem Befehl “DapiSpecialCMDAD” aktiviert, bzw. initialisiert werden muss.

 

Programmierbeispiel

bytes_received = DapiReadFifo(handle, DAPI_FIFO_TYPE_READ_AD_FIFO, buffer, sizeof(buffer));
//Reads the Software FIFO

CNT48-Funktionen

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

DapiCnt48ModeSet

 

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

 

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

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

DapiCnt48ModeGet

 

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

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

DapiCnt48CounterGet32

 

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

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

DapiCnt48CounterGet48

 

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

DapiSpecialCommand - DapiSpecialDIFilterValueSet
Dieser Befehl setzt einen Filter [ms], in welchem Zeitintervall digitale Eingangskanäle abgetastet werden

DapiSpecialCommand – Dapi_Special_DI_Filter_Value_Set

 

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

DapiSpecialCommand - DapiSpecialDIFilterValueGet
Dieser Befehl gibt den vorher festgelegten Wert des Zeitintervalls zur Abtastung der digitalen Eingangskanäle in [ms] zurück

DapiSpecialCommand – Dapi_Special_DI_Filter_Value_Get

 

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.

DapiSpecialCommand - Dapi_Special_DI_FF_Filter_Value_Set
Dieser Befehl setzt einen Filter [ms], in welchem Zeitintervall die Eingangs-Flip-Flops und die Eingangs-Zähler abgefragt werden

DapiSpecialCommand – Dapi_Special_DI_FF_Filter_Value_Set

 

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

DapiSpecialCommand - Dapi_Special_DI_FF_Filter_Value_Get
Dieser Befehl gibt den vorher festgelegten Wert des Zeitintervalls zur Abtastung der Eingangs-Flip-Flops und der Eingangs-Zähler in [ms] zurück

DapiSpecialCommand – Dapi_Special_DI_FF_Filter_Value_Get

 

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.

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

DapiSpecialCommand – DapiSpecialCNT48LatchGroup8

 

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

DapiSpecialCommand - DapiSpecialCNT48ResetGroup8
Dieser Befehl resettet gleichzeitig die Zählerstände von 8 Eingangszählern.

DapiSpecialCommand – DapiSpecialCNT48ResetGroup8

 

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

DapiSpecialCommand - DapiSpecialCNT48ResetSingle
Dieser Befehl resettet den Zählerstand eines einzelnen Eingangszählers.

DapiSpecialCommand – DapiSpecialCNT48ResetSingle

 

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

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

DapiSpecialCommand – DapiSpecialCNT48DIGet1

 

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

Puls-Gen-Funktionen

DapiPulseGenSet
Dieser Befehl generiert eine gewisse Anzahl an Impulsen mit vorgegebenen low- und high-Zeiten.

DapiPulseGenSet

 

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

 

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.

Register-Funktionen

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

DapiWriteByte

 

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.

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

DapiWriteWord

 

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.

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

DapiWriteLong

 

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.

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

DapiWriteLongLong

 

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.

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

DapiReadByte

 

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.

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

DapiReadWord

 

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.

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

DapiReadLong

 

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.

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

DapiReadLongLong

 

Beschreibung

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

 

Definition

ULONGLONG DapiReadLongLong(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 (64 Bit)

 

Bemerkung

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