Deditec USB-RS485-STICK Hardware-Description [de]

USB-RS485-STICK

Hardware-Beschreibung

2010

September

INDEX

1. Einleitung 4

1.1. Vorwort 4

1.2. Kundenzufriedenheit 4

1.3. Kundenresonanz 4

2. Hardware Beschreibung 6

2.1. Einführung 6

2.2. Technische Daten 7

2.3. Pinbelegung Steckverbinder (9pol. D-SUB Stecker) 8

2.4. Kontroll LED's 8

3. Software 10

3.1. Installation "VCP Treiber (Virtueller COM-Port)" 10

4. Anhang 13

4.1. Bestellinformation 13

4.2. Revisionen 14

4.3. Urheberrechte und Marken 15

Index | 2Seite

Einleitung

I

Einleitung | Seite 3

1. Einleitung

1.1. Vorwort

Wir beglückwünschen Sie zum Kauf eines hochwertigen DEDITEC Produktes!

Unsere Produkte werden von unseren Ingenieuren nach den heutigen
geforderten Qualitätsanforderungen entwickelt. Wir achten bereits bei der
Entwicklung auf flexible Erweiterbarkeit und lange Verfügbarkeit.

Wir entwickeln modular!

Durch eine modulare Entwicklung verkürzt sich bei uns die Entwicklungszeit
und - was natürlich dem Kunden zu Gute kommt - ein fairer Preis!

Wir sorgen für eine lange Lieferverfügbarkeit!

Sollten verwendete Halbleiter nicht mehr verfügbar sein, so können wir
schneller reagieren. Bei uns müssen meistens nur Module redesigned werden
und nicht das gesamte Produkt. Dies erhöht die Lieferverfügbarkeit.

1.2. Kundenzufriedenheit

Ein zufriedener Kunde steht bei uns an erster Stelle!
Sollte mal etwas nicht zu Ihrer Zufriedenheit sein, wenden Sie sich einfach per

Telefon oder mail an uns.
Wir kümmern uns darum!

1.3. Kundenresonanz

Die besten Produkte wachsen mit unseren Kunden. Für Anregungen oder
Vorschläge sind wir jederzeit dankbar.

Einleitung | Seite 4

Hardware Beschreibung

II

Hardware Beschreibung |Seite 5

2. Hardware Beschreibung

2.1. Einführung

Mit diesem handlichen Stick verbinden Sie Ihren PC/Notebook mit der Welt der
RS-485 Geräte. Die galvanische Trennung bewirkt eine elektrische Trennung
des PC's zur RS-485 Schnittstelle. Störende Impulse auf der RS-485 Seite, die
solch einen Konverter zerstören, gehören damit zur Vergangenheit.

Durch die galvanische Trennung können auch Industrieanlagen mit dem PC
verbunden werden, die auf einem anderen elektrischem Level liegen, wie der
verwendete PC oder Notebook.

Hardware Beschreibung |Seite 6

2.2. Technische Daten

+5V Spannungsversorgung
USB auf RS-485 Konverter
Galvanisch getrennt
50 Baud ..115200 Baud (per Software konfigurierbar)
Windows VCP (Virtueller COM Port)
Linux Treiber inklusive
Abmessung: 84,5 x 21 x 12,5/9,5 mm (ohne Kabel)

Hardware Beschreibung |Seite 7

2.3. Pinbelegung Steckverbinder (9pol. D-SUB Stecker)

Pin2RS-485 B

7

RS-485 A

Der Anschluss an den Stick erfolgt auf der RS-485 Seite mittels eines 9pol.
DSUB Steckers.

RS-485 Pinbelegung

2.4. Kontroll LED's

Zwei LED signalisieren Sende- und Empfangsereignisse.

1*TX (senden)
1*RX (empfangen)

Hardware Beschreibung |Seite 8

Software

III

Software | Seite 9

3. Software

3.1. Installation "VCP Treiber (Virtueller COM-Port)"

Legen Sie die DEDITEC driver CD in das Laufwerk und starten Sie
“vcp_driver_install.exe”. Die “VCP Treiber (Virtueller COM-Port)” Software ist

auch unter http://www.deditec.de/de/entwicklungstools/download.html
erhältlich.

Software | Seite 10

Drücken Sie auf “Install”.

Die Treiber werden nun installiert.

Die “VCP Treiber (Virtueller COM-Port)” Software wurde nun installiert. Drücken
sie auf “Close” um die Installation zu beenden.

Software | Seite 11

Anhang

IV

Anhang | Seite 12

4. Anhang

4.1. Bestellinformation

Best.Nr.: USB-RS485-STICK

Produkt: USB-RS-485-Konverter mit galvanischer Trennung

Produktlink: http://www.deditec.de/de/entwicklungstools/prod/usb-rs485-

stick.html

Anhang | Seite 13

4.2. Revisionen

Rev 1.00 Erste DEDITEC Anleitung
Rev 2.00 Designänderung

Anhang | Seite 14

4.3. Urheberrechte und Marken

Linux ist eine registrierte Marke von Linus Torvalds.

Windows CE ist eine registrierte Marke von Microsoft Corporation.

USB ist eine registrierte Marke von USB Implementers Forum Inc.

LabVIEW ist eine registrierte Marke von National Instruments.

Intel ist eine registrierte Marke von Intel Corporation

AMD ist eine registrierte Marke von Advanced Micro Devices, Inc.

Anhang | Seite 15

DELIB

DEDITEC Treiber Bibliothek

2010

Dezember

INDEX

1. Software 7

1.1. Benutzung unserer Produkte 7

1.1.1. Ansteuerung über grafische Anwendungen

1.1.2. Ansteuerung über unsere DELIB Treiberbibliothek

1.1.3. Ansteuerung auf Protokollebene

1.1.4. Ansteuerung über mitgelieferte Testprogramme

1.2. DELIB Treiberbibliothek 9

1.2.1. Übersicht

1.2.2. Unterstützte Betriebssysteme

1.2.3. Unterstützte Programmiersprachen

1.2.4. Installation DELIB-Treiberbibliothek

1.2.5. DELIB Configuration Utility

11
11

12

14

1.3. Testprogramme 15

1.3.1. Digital Input-Output Demo

1.3.2. Analog Input-Output Demo

1.3.3. Stepper Demo

15
16

17

2. Verzeichnisstruktur der DELIB 19

2.1. Include Verzeichnis 19

7
7
7

8

9

2.2. Library-Verzeichnis 19

2.3. Library-Verzeichnis für Borland 20

2.4. Umgebungsvariablen 20

3. DELIB API Referenz 22

3.1. Verwaltungsfunktionen 22

3.1.1. DapiOpenModule

3.1.2. DapiCloseModule

22
23

3.2. Fehlerbehandlung 24

3.2.1. DapiGetLastError

3.2.2. DapiGetLastErrorText

24

25

Index |

2Seite

INDEX

3.3. Digitale Eingänge lesen 26

3.3.1. DapiDIGet1

3.3.2. DapiDIGet8

3.3.3. DapiDIGet16

3.3.4. DapiDIGet32

3.3.5. DapiDIGet64

3.3.6. DapiDIGetFF32

3.3.7. DapiDIGetCounter

26

27
28
29
30

31
32

3.4. Digitale Ausgänge verwalten 33

3.4.1. DapiDOSet1

3.4.2. DapiDOSet8

3.4.3. DapiDOSet16

3.4.4. DapiDOSet32

3.4.5. DapiDOSet64

3.4.6. DapiDOReadback32

3.4.7. DapiDOReadback64

33

34
35
36

37
38
39

3.5. A/D Wandler Funktionen 40

3.5.1. DapiADSetMode

3.5.2. DapiADGetMode

3.5.3. DapiADGet

3.5.4. DapiADGetVolt

3.5.5. DapiADGetmA

40

42

43

44

45

3.6. D/A Ausgänge verwalten 46

3.6.1. DapiDASetMode

3.6.2. DapiDAGetMode

3.6.3. DapiDASet

3.6.4. DapiDASetVolt

3.6.5. DapiDASetmA

3.6.6. DapiSpecialCmd_DA

46

48

49
50

51
52

3.7. TTL-Ein-/Ausgangs Richtungen setzen mit DapiSpecialCommand54

3.7.1. DAPI_SPECIAL_CMD_SET_DIR_DX_1

3.7.2. DAPI_SPECIAL_CMD_SET_DIR_DX_8

54
55

3.8. Schrittmotoren Funktionen 56

3.8.1. Befehle mit DapiStepperCommand

56

Index |

3Seite

INDEX

3.8.1.1. DAPI_STEPPER_CMD_GO_POSITION

3.8.1.2.
DAPI_STEPPER_CMD_GO_POSITION_RELATIVE

3.8.1.3. DAPI_STEPPER_CMD_SET_POSITION

3.8.1.4. DAPI_STEPPER_CMD_SET_FREQUENCY

3.8.1.5. DAPI_STEPPER_CMD_GET_FREQUENCY

3.8.1.6.
DAPI_STEPPER_CMD_SET_FREQUENCY_DIRECTLY

3.8.1.7. DAPI_STEPPER_CMD_STOP

3.8.1.8. DAPI_STEPPER_CMD_FULLSTOP

3.8.1.9. DAPI_STEPPER_CMD_DISABLE

3.8.1.10.
DAPI_STEPPER_CMD_SET_MOTORCHARACTERISTIC

3.8.1.11.
DAPI_STEPPER_CMD_GET_MOTORCHARACTERISTIC

3.8.1.12.
DAPI_STEPPER_CMD_MOTORCHARACTERISTIC_EEP
ROM_SAVE

3.8.1.13.
DAPI_STEPPER_CMD_MOTORCHARACTERISTIC_EEP
ROM_LOAD

3.8.1.14.
DAPI_STEPPER_CMD_MOTORCHARACTERISTIC_LOA
D_DEFAULT

3.8.1.15. DAPI_STEPPER_CMD_GO_REFSWITCH

3.8.1.16. DAPI_STEPPER_CMD_GET_CPU_TEMP

3.8.1.17.
DAPI_STEPPER_CMD_GET_MOTOR_SUPPLY_VOLTAG
E

3.8.2. Status abfragen mit DapiStepperGetStatus

3.8.2.1. DAPI_STEPPER_STATUS_GET_ACTIVITY

3.8.2.2. DAPI_STEPPER_STATUS_GET_POSITION

3.8.2.3. DAPI_STEPPER_STATUS_GET_SWITCH

3.8.3. DapiStepperCommandEx

56

57
58
59
60

61
62

63

64

65

70

78

79

80

81

83

84

85

85
86

87

88

3.9. Ausgabe-Timeout verwalten 89

3.9.1. DapiSpecialCMDTimeout

3.9.2. DapiSpecialCMDTimeoutGetStatus

89
90

3.10. Testfunktionen 91

3.10.1. DapiPing

91

Index |

4Seite

INDEX

3.11. Register Schreib-Befehle 92

3.11.1. DapiWriteByte

3.11.2. DapiWriteWord

3.11.3. DapiWriteLong

3.11.4. DapiWriteLongLong

92
93

94

95

3.12. Register Lese-Befehle 96

3.12.1. DapiReadByte

3.12.2. DapiReadWord

3.12.3. DapiReadLong

3.12.4. DapiReadLongLong

96

97
98
99

3.13. Programmier-Beispiel 100

4. Anhang 103

4.1. Revisionen 103

4.2. Urheberrechte und Marken 104

Index |

5Seite

Software

I

Software |

Seite 6

1. Software

1.1. Benutzung unserer Produkte

1.1.1. Ansteuerung über grafische Anwendungen

Wir stellen Treiberinterfaces z.B. für LabVIEW und ProfiLab zur Verfügung. Als
Basis dient die DELIB Treiberbibliothek, die von ProfiLab direkt angesteuert
werden kann.

Für LabVIEW bieten wir eine einfache Treiberanbindung mit Beispielen an!

1.1.2. Ansteuerung über unsere DELIB Treiberbibliothek

Im Anhang befindet sich die komplette Funktionsreferenz für das Integrieren
unserer API-Funktionen in Ihre Software. Des Weiteren bieten wir passende
Beispiele für folgende Programmiersprachen:

C
C++
C#
Delphi
VisualBasic
VB.NET
MS-Office

1.1.3. Ansteuerung auf Protokollebene

Das Protokoll für die Ansteuerung unserer Produkte legen wir komplett offen. So
können Sie auch auf Systemen ohne Windows oder Linux unsere Produkte
einsetzen!

Software |

Seite 7

1.1.4. Ansteuerung über mitgelieferte Testprogramme

Für die wichtigsten Funktionen unserer Produkte stellen wir einfach zu
bedienende Testprogramme zur Verfügung,. Diese werden bei der Installation
der DELIB Treiberbibliothek direkt mit installiert.

So können z.B. Relais direkt getestet werden oder Spannungen am A/D Wandler
direkt überprüft werden.

Software |

Seite 8

1.2. DELIB Treiberbibliothek

1.2.1. Übersicht

Die folgende Abbildung erläutert den Aufbau der DELIB Treiberbibliothek

Die DELIB Treiberbibliothek ermöglicht ein einheitliches Ansprechen von
DEDITEC Hardware, mit der besonderen Berücksichtigung folgender
Gesichtspunkte:

Betriebssystem unabhängig
Programmiersprachen unabhängig
Produkt unabhängig

Programmieren unter diversen Betriebssystemen

Die DELIB Treiberbibliothek ermöglicht ein einheitliches Ansprechen unserer
Produkte auf diversen Betriebssystemen.
Wir haben dafür gesorgt, dass mit wenigen Befehlen alle unsere Produkte
angesprochen werden können.
Dabei spielt es keine Rolle, welches Betriebssystem Sie verwenden. - Dafür
sorgt die DELIB !

Software |

Seite 9

Programmieren mit diversen Programmiersprachen

Für das Erstellen eigener Anwendungen stellen wir Ihnen einheitliche Befehle
zur Verfügung. Dies wird über die DELIB Treiberbibliothek gelöst.

Sie wählen die Programmiersprache !

So können leicht Anwendung unter C++, C, Visual Basic, Delphi oder
LabVIEW® entwickelt werden.

Schnittstellenunabhängiges programmieren

Schreiben Sie Ihre Anwendung schnittstellenunabhängig !
Programmieren Sie eine Anwendung für ein USB-Produkt von uns. - Es wird
auch mit einem Ethernet oder RS-232 Produkt von uns laufen !

SDK-Kit für Programmierer

Integrieren Sie die DELIB in Ihre Anwendung. Auf Anfrage erhalten Sie von uns
kostenlos Installationsskripte, die es ermöglichen, die DELIB Installation in Ihre
Anwendung mit einzubinden.

Software |

Seite 10

1.2.2. Unterstützte Betriebssysteme

Unsere Produkte unterstützen folgende Betriebssysteme:

Windows 2000
Windows XP
Windows Vista
Windows 7
Linux

1.2.3. Unterstützte Programmiersprachen

Unsere Produkte sind über folgende Programmiersprachen ansprechbar:

C
C++
C#
Delphi
VisualBasic
VB.NET
MS-Office

Software |

Seite 11

1.2.4. Installation DELIB-Treiberbibliothek

Legen Sie die DEDITEC driver CD in das Laufwerk und starten Sie
“delib_install.exe”. Die DELIB-Treiberbibliothek ist auch unter http://www.

deditec.de/delib erhältlich.

Drücken Sie auf “Install”.

Software |

Seite 12

Die Treiber werden nun installiert.

Die DELIB Treiberbibliothek wurde nun Installiert. Drücken sie auf “Close” um
die Installation zu beenden.

Mit dem “DELIB Configuration Utility” (nächstes Kapitel) können Sie Ihr Modul
konfigurieren (dies ist nur nötig, wenn Sie mehr als ein Modul ansprechen
möchten).

Software |

Seite 13

1.2.5. DELIB Configuration Utility

“DELIB Configuration Utility” wird auf dem folgendem Weg gestartet:
Start Programme DEDITEC DELIB DELIB Configuration Utility.

Das “DELIB Configuration Utility” ist ein Programm zur Konfiguration und
Unterteilung Identischer USB-Module im System. Dies ist aber nicht nötig falls
nur ein Modul vorhanden ist.

Weiteres zum Inhalt der “DELIB Installation”, siehe “Manual für DELIB

Treiberbibliothek”

Software |

Seite 14

1.3. Testprogramme

1.3.1. Digital Input-Output Demo

“Digital Input-Output Demo” wird auf dem folgendem Weg gestartet:
Start Programme DEDITEC DELIB Digital Input-Output Demo.

Diese Grafik zeigt einen Test des RO-USB-O64-R64. Oben links kann man die
Konfiguration des Moduls ablesen (64 Eingänge und 64 Ausgänge).

Software |

Seite 15

1.3.2. Analog Input-Output Demo

“Analog Input-Output Demo” wird auf dem folgendem Weg gestartet:
Start Programme DEDITEC DELIB Analog Input-Output Demo.

Diese Grafik zeigt einen Test des RO-USB-AD16-DA4. Oben links kann man
die Konfiguration des Moduls ablesen (16 A/D-Eingänge und 4 D/A-Ausgänge).

Software |

Seite 16

1.3.3. Stepper Demo

“Stepper Demo” wird auf dem folgendem Weg gestartet:
Start Programme DEDITEC DELIB Stepper Demo.

Diese Grafik zeigt einen Test des RO-USB-STEPPER2. Oben links kann man
die Konfiguration des Moduls ablesen (2 Stepper).

Software |

Seite 17

Verzeichnisstruktur der DELIB

II

Verzeichnisstruktur der DELIB |

Seite 18

2. Verzeichnisstruktur der DELIB

Nach erfolgreicher Installation liegt folgender Verzeichnissbaum vor:

C:\Programme\DEDITEC\DELIB\

> include Includes für Programmiersprachen ( Abschnitt 3.1.1)
> lib Library ( Abschnitt 3.1.2)
> lib\bc Borland Compiler Library ( Abschnitt 3.1.2)
> programs Modul-Testprogramme ( Abschnitt 2.3)
> USB-Driver Treiber für USB-Module

Zudem wurde auch in C:\WINNT\system32\ die Datei delib.dll sowie diverse
USB Systemtreiber installiert.

2.1. Include Verzeichnis

Das für die DELIB angelegte Include-Verzeichnis enthält die Dateien, welche
die entsprechenden Library-Funktionen beschreiben. Diese sind für die
Programmiersprachen C (.h), Delphi (.pas) und Visual Basic (.bas) gegeben.

2.2. Library-Verzeichnis

Hierin befindet sich die Datei “DELIB.lib”. Sie dient als Bindeglied für das
Compilieren von eigenen Programmen, die die “DELIB.dll” benutzen.

Verzeichnisstruktur der DELIB |

Seite 19

2.3. Library-Verzeichnis für Borland

Für Borland Compiler gibt es eine separate DELIB.lib, die sich im
Unterverzeichnis “bc” befindet. Diese dient ebenfalls als Bindeglied für das
Compilieren von eigenen Programmen, die die “DELIB.dll” benutzen.

2.4. Umgebungsvariablen

Zwei Umgebungsvariablen weisen auf wichtige Verzeichnisse hin, die Dateien
für die Programmiersprachen C, Delphi und Visual Basic enthalten.

“DELIB_INCLUDE” zeigt auf das Include-Verzeichnis.

%DELIB_INCLUDE% c:\Programme\DEDITEC\DELIB\include"

“DELIB_LIB” zeigt auf das Library-Verzeichnis.

%DELIB_LIB% c:\ Programme\DEDITEC\DELIB\lib

Verzeichnisstruktur der DELIB |

Seite 20

DELIB API Referenz

III

DELIB API Referenz |

Seite 21

3. DELIB API Referenz

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

3.1. Verwaltungsfunktionen

3.1.1. 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ückgegebene Handle wird zur Identifikation des
Moduls für alle anderen Funktionen benötigt.

Programmierbeispiel

DELIB API Referenz |

Seite 22

3.1.2. DapiCloseModule

// Modul schliessen
DapiCloseModule(handle);

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

DELIB API Referenz |

Seite 23

3.2. Fehlerbehandlung

ULONG error;
error=DapiGetLastError();
if(error==0) return FALSE;
printf("ERROR = %d”, error);

3.2.1. DapiGetLastError

Beschreibung

Diese Funktion liefert den letzten erfassten Fehler.

Definition

ULONG DapiGetLastError();

Parameter

Keine

Return-Wert

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

Programmierbeispiel

DELIB API Referenz |

Seite 24

3.2.2. DapiGetLastErrorText

BOOL IsError ()
{
if (DapiGetLastError () != DAPI_ERR_NONE)

{
unsigned char msg[500];

DapiGetLastErrorText((unsigned char*) msg, sizeof(msg));
printf ("Error Code = %x * Message = %s\n", 0, msg);
return TRUE;

}
return FALSE;
}

Beschreibung

Diese Funktion liest den Text des letzten erfassten Fehlers.

Definition

extern ULONG __stdcall 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

DELIB API Referenz |

Seite 25

3.3. Digitale Eingänge lesen

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

DELIB API Referenz |

Seite 26

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

DELIB API Referenz |

Seite 27

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

DELIB API Referenz |

Seite 28

3.3.4. DapiDIGet32

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

Beschreibung

Dieser Befehl liest gleichzeitig 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

Programmierbeispiel

DELIB API Referenz |

Seite 29

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

DELIB API Referenz |

Seite 30

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

DELIB API Referenz |

Seite 31

3.3.7. DapiDIGetCounter

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

Beschreibung

Dieser Befehl liest den Eingangszähler eines digitalen Eingangs.

Definition

ULONG DapiDIGetCounter(handle, ch, par1);

Parameter

handle=Dies ist das Handle eines geöffneten Moduls
ch=Gibt die Nummer des Eingangs an, ab dem gelesen werden soll
par1=0 (Normale Zählfunktion)
par1=DAPI_CNT_MODE_READ_WITH_RESET (Zähler auslesen und direktes

Counter resetten)

Return-Wert

Angabe des Zählerwertes

Programmierbeispiel

DELIB API Referenz |

Seite 32

3.4. Digitale Ausgänge verwalten

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

DELIB API Referenz |

Seite 33

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

DELIB API Referenz |

Seite 34

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

DELIB API Referenz |

Seite 35

3.4.4. DapiDOSet32

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

Beschreibung

Dieser Befehl setzt gleichzeitig 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

DELIB API Referenz |

Seite 36

3.4.5. DapiDOSet64

Beschreibung

Dieser Befehl setzt gleichzeitig 64 digitale Ausgänge.

Definition

void DapiDOSet64(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, 64,

..)
data=Gibt die Datenwerte an, die geschrieben werden

Return-Wert

Keiner

DELIB API Referenz |

Seite 37

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

DELIB API Referenz |

Seite 38

3.4.7. DapiDOReadback64

Beschreibung

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

Definition

ULONGLONG DapiDOReadback64(ULONG handle, ULONG ch);

Parameter

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

64, ..)

Return-Wert

Zustand von 64 Ausgängen.

DELIB API Referenz |

Seite 39

3.5. A/D Wandler Funktionen

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

DELIB API Referenz |

Seite 40

Ströme:

ADDA_MODE_0_20mA
ADDA_MODE_4_20mA
ADDA_MODE_0_24mA
ADDA_MODE_0_25mA
ADDA_MODE_0_50mA

DELIB API Referenz |

Seite 41

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

DELIB API Referenz |

Seite 42

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

DELIB API Referenz |

Seite 43

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

DELIB API Referenz |

Seite 44

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

DELIB API Referenz |

Seite 45

3.6. D/A Ausgänge verwalten

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

DELIB API Referenz |

Seite 46

Ströme:

ADDA_MODE_0_20mA
ADDA_MODE_4_20mA
ADDA_MODE_0_24mA
ADDA_MODE_0_25mA
ADDA_MODE_0_50mA

DELIB API Referenz |

Seite 47

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

DELIB API Referenz |

Seite 48

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

DELIB API Referenz |

Seite 49

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

DELIB API Referenz |

Seite 50

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

DELIB API Referenz |

Seite 51

3.6.6. DapiSpecialCmd_DA

Beschreibung

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

Definition

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

Parameter

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

Zurücksetzen der Einstellungen auf Default Konfiguration

cmd=DAPI_SPECIAL_DA_PAR_DA_LOAD_DEFAULT

Speichern der Konfiguration in das EEPROM

cmd=DAPI_SPECIAL_DA_PAR_DA_SAVE_EEPROM_CONFIG

Laden der Konfiguration aus dem EEPROM

cmd=DAPI_SPECIAL_DA_PAR_DA_LOAD_EEPROM_CONFIG

Return-Wert

Keiner

Bemerkung
DAPI_SPECIAL_CMD_DA_PAR_DA_LOAD_DEFAULT

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

DAPI_SPECIAL_DA_PAR_DA_SAVE_EEPROM_CONFIG

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

DAPI_SPECIAL_DA_PAR_DA_LOAD_EEPROM_CONFIG

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

DELIB API Referenz |

Seite 52

Programmierbeispiel

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_DA,
DAPI_SPECIAL_DA_PAR_DA_LOAD_DEFAULT, 1, 0);
//Zurücksetzen der EEPROM-Konfiguration auf Default Konfiguration bei Kanal 1.

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_DA,
DAPI_SPECIAL_DA_PAR_DA_SAVE_EEPROM_CONFIG, 3, 0);
//Speichern der D/A Wandler Einstellungen in das EEPROM bei Kanal 3.

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_DA,
DAPI_SPECIAL_DA_PAR_DA_LOAD_EEPROM_CONFIG, 2, 0);
//Setzen des D/A Wandlers, mit der im EEPROM gespeicherten Konfiguration bei
Kanal 2.

DELIB API Referenz |

Seite 53

3.7. TTL-Ein-/Ausgangs Richtungen setzen mit

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

3.7.1. DAPI_SPECIAL_CMD_SET_DIR_DX_1

Beschreibung

Dieser Befehl setzt die Richtung von 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=Gibt die Nummer des Ausgangs an, ab dem die Richtung gesetzt werden

soll (0, 1, 2, 3, 4 ..)
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 ...

Programmierbeispiel

DELIB API Referenz |

Seite 54

3.7.2. DAPI_SPECIAL_CMD_SET_DIR_DX_8

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SET_DIR_DX_8, 0, 1, 0);
// Set Dir of TTL-I/O CH0 to out

Beschreibung

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

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=Gibt die Nummer des Ausgangs an, ab dem die Richtung gesetzt werden

soll (0, 8, 16, 24 ..). Zwischenwerte sind ungültig
dir=(8-Bit) gibt die Richtung für 8 hintereinanderliegende Ein/Ausgänge an.

(1=output / 0=input)

Programmierbeispiel

DELIB API Referenz |

Seite 55

3.8. Schrittmotoren Funktionen

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

3.8.1. Befehle mit DapiStepperCommand

3.8.1.1. DAPI_STEPPER_CMD_GO_POSITION

Beschreibung

Hiermit wird eine bestimmte Position angefahren. Dieses Kommando darf nur
ausgeführt werden, wenn der Motor nicht "disabled" ist und kein Go_Position
oder Go_Referenz ausgeführt wird.

Definition

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

Programmierbeispiel

DELIB API Referenz |

Seite 56

3.8.1.2. DAPI_STEPPER_CMD_GO_POSITION_RELATIVE

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

Beschreibung

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

Programmierbeispiel

DELIB API Referenz |

Seite 57

3.8.1.3. DAPI_STEPPER_CMD_SET_POSITION

Beschreibung

Dieses Kommando dient zum setzten 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

DELIB API Referenz |

Seite 58

3.8.1.4. DAPI_STEPPER_CMD_SET_FREQUENCY

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]

DELIB API Referenz |

Seite 59

3.8.1.5. DAPI_STEPPER_CMD_GET_FREQUENCY

Beschreibung

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

Definition

DapiStepperCommand(handle, motor, DAPI_STEPPER_CMD_GET_FREQUENCY,
par1, 0 ,0 ,0);

Return-Wert

Motorfrequenz [Hz]

DELIB API Referenz |

Seite 60

3.8.1.6. DAPI_STEPPER_CMD_SET_FREQUENCY_DIRECTLY

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]

DELIB API Referenz |

Seite 61

3.8.1.7. DAPI_STEPPER_CMD_STOP

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

DELIB API Referenz |

Seite 62

3.8.1.8. DAPI_STEPPER_CMD_FULLSTOP

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

Beschreibung

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

Definition

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

Programmierbeispiel

DELIB API Referenz |

Seite 63

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

DELIB API Referenz |

Seite 64

3.8.1.10. DAPI_STEPPER_CMD_SET_MOTORCHARACTERISTIC

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)

DELIB API Referenz |

Seite 65

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)

DELIB API Referenz |

Seite 66

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

par2=Geschwindigkeit, mit der der Enschalter angefahren wird (Frequenz
[Vollschritt / s] - (Maximalwert=5000))

DELIB API Referenz |

Seite 67

Parameter GoReferenceFrequencyAfterEndSwitch setzen

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 (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);
// Beschleunigun 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,

par1=DAPI_STEPPER_MOTORCHAR_PAR_GOREFERENCEFREQUENCY_AFT
ERENDSWITCH

par2=Geschwindigkeit, mit der vom Enschalter abgefahren wird (Frequenz
[Vollschritt / s] - (Maximalwert=5000))

Parameter GoReferenceFrequencyToOffset setzen

par1=DAPI_STEPPER_MOTORCHAR_PAR_GOREFERENCEFREQUENCY_TO
OFFSET

par2=Geschwindigkeit, mit der der optionale Offset angefahren wird (Frequenz
[Vollschritt / s] - (Maximalwert=5000))

Programmierbeispiel

DELIB API Referenz |

Seite 68

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.

DELIB API Referenz |

Seite 69

3.8.1.11. DAPI_STEPPER_CMD_GET_MOTORCHARACTERISTIC

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

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

DELIB API Referenz |

Seite 70

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

DELIB API Referenz |

Seite 71

Parameter GoReferenceFrequencyAfterEndSwitch abfragen

par1=DAPI_STEPPER_MOTORCHAR_PAR_GOREFERENCEFREQUENCY_AFT
ERENDSWITCH

Parameter GoReferenceFrequencyToOffSet abfragen

par1=DAPI_STEPPER_MOTORCHAR_PAR_GOREFERENCEFREQUENCY_TO
OFFSET

DELIB API Referenz |

Seite 72

Return-Wert
Parameter-Stepmode ablesen

par1=DAPI_STEPPER_MOTORCHAR_PAR_STEPMODE
return=0 (Vollschrittbetrieb)
return=1 (Halbschrittbetrieb)
return=2 (Viertelschrittbetrieb)
return=3 (Achtelschrittbetrieb)
return=4 (Sechzehntelschrittbetrieb)

Parameter-GO-Frequency

par1=DAPI_STEPPER_MOTORCHAR_PAR_GOFREQUENCY
return=Geschwindigkeit [Vollschritt / s] - bezogen auf Vollschritt

Parameter-Start-Frequency

par1=DAPI_STEPPER_MOTORCHAR_PAR_STARTFREQUENCY
return=Startfrequenz [Vollschritt / s]

Parameter-Stop-Frequency

par1=DAPI_STEPPER_MOTORCHAR_PAR_STOPFREQUENCY
return=Stopfrequenz [Vollschritt / s]

Parameter-Max-Frequency

par1=DAPI_STEPPER_MOTORCHAR_PAR_MAXFREQUENCY
return=maximale Frequenz [Vollschritt / s]

Parameter-Accelerationslope

par1=DAPI_STEPPER_MOTORCHAR_PAR_ACCELERATIONSLOPE
return=Beschleunigungsrampe [Vollschritten / ms]

Parameter-Decelerationslope

par1=DAPI_STEPPER_MOTORCHAR_PAR_DECELERATIONSLOPE
return= Bremsrampe [Vollschritten / ms]

DELIB API Referenz |

Seite 73

Parameter-Phasecurrent

par1=DAPI_STEPPER_MOTORCHAR_PAR_PHASECURRENT
return=Phasenstrom [mA]

Parameter-Hold-Phasecurrent

par1=DAPI_STEPPER_MOTORCHAR_PAR_HOLDPHASECURRENT
return= Phasenstrom bei Motorstillstand [mA]

Parameter-Hold-Time

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

Parameter-Status-LED-Mode

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

par1=DAPI_STEPPER_MOTORCHAR_PAR_INVERT_ENDSW1
return=Endschalter1 wird invertiert (0=normal / 1=invertieren)

Parameter-Invert-END-Switch2

par1=DAPI_STEPPER_MOTORCHAR_PAR_INVERT_ENDSW2
return=Endschalter2 wird invertiert (0=normal / 1=invertieren)

Parameter-Invert-Ref-Switch1

par1=DAPI_STEPPER_MOTORCHAR_PAR_INVERT_REFSW1
return=Referenzschalterschalter1 wird invertiert (0=normal / 1=invertieren)

DELIB API Referenz |

Seite 74

Parameter-Invert-Ref-Switch2

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,

par1=DAPI_STEPPER_MOTORCHAR_PAR_INVERT_REFSW2
return=Referenzschalterschalter2 wird invertiert (0=normal / 1=invertieren)

Parameter-Invert-direction

par1=DAPI_STEPPER_MOTORCHAR_PAR_INVERT_DIRECTION
return=Richtungsangaben werden invertiert (0=normal / 1=invertieren)

Parameter-Endswitch-Stopmode

par1= DAPI_STEPPER_MOTORCHAR_PAR_ENDSWITCH_STOPMODE
return=Einstellung des Stopverhaltens (0=Fullstop / 1=Stop)

Parameter-GoReferenceFrequnecyToEndSwitch

par1=DAPI_STEPPER_MOTORCHAR_PAR_GOREFERENCEFREQUENCY_TOE
NDSWITCH

return=Frequenz [Vollschritt / s]

Parameter GoReferenceFrequencyAfterEndSwitch abfragen

par1=DAPI_STEPPER_MOTORCHAR_PAR_GOREFERENCEFREQUENCY_AFT
ERENDSWITCH

return=Frequenz [Vollschritt / s]

Parameter GoReferenceFrequencyToOffset abfragen

par1=DAPI_STEPPER_MOTORCHAR_PAR_GOREFERENCEFREQUENCY_TO
OFFSET

return=Frequenz [Vollschritt / s]

Programmierbeispiel

DELIB API Referenz |

Seite 75

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

DELIB API Referenz |

Seite 76

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

DELIB API Referenz |

Seite 77

3.8.1.12.
DAPI_STEPPER_CMD_MOTORCHARACTERISTIC_EEPROM_SAVE

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

DELIB API Referenz |

Seite 78

3.8.1.13.
DAPI_STEPPER_CMD_MOTORCHARACTERISTIC_EEPROM_LOAD

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

DELIB API Referenz |

Seite 79

3.8.1.14.
DAPI_STEPPER_CMD_MOTORCHARACTERISTIC_LOAD_DEFAULT

Beschreibung

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

Definition

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

Bemerkung

Die Defaultwerte sind folgende:

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

DELIB API Referenz |

Seite 80

3.8.1.15. DAPI_STEPPER_CMD_GO_REFSWITCH

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

DELIB API Referenz |

Seite 81

Herausfahren aus dem Referenzschalter

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

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

DELIB API Referenz |

Seite 82

3.8.1.16. DAPI_STEPPER_CMD_GET_CPU_TEMP

Beschreibung

Die Temperatur des CPU wird abgefragt.

Definition

ULONG DapiStepperCommand(handle, motor,
DAPI_STEPPER_CMD_GET_CPU_TEMP);

Parameter

cmd=DAPI_STEPPER_CMD_GET_CPU_TEMP

Return-Wert

Temperatur [°C]

DELIB API Referenz |

Seite 83

3.8.1.17. DAPI_STEPPER_CMD_GET_MOTOR_SUPPLY_VOLTAGE

Beschreibung

Hiermit wird die Versorgungsspannung des Motors abgefragt.

Definition

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

Parameter

cmd=DAPI_STEPPER_CMD_GET_MOTOR_SUPPLY_VOLTAGE

Return-Wert

Motorversorgungsspannung in [mV]

DELIB API Referenz |

Seite 84

3.8.2. Status abfragen mit DapiStepperGetStatus

Bit

Command

Beschreibung

0

DISABLE

Motor darf nicht verfahren

1

MOTORSTROMACTIV

Motorstrom ist aktiv

2

HALTESTROMACTIV

Haltestrom ist aktiv

3

GOPOSITIONACTIV

GoPosition ist akitv

4

GOPOSITIONBREMSEN

GoPosition Bremsung ist aktiv

5

GOREFERENZACTIV

GoReference ist aktiv

ret = DapiStepperGetStatus(handle, motor, DAPI_STEPPER_STATUS_GET_ACTIVITY);

3.8.2.1. DAPI_STEPPER_STATUS_GET_ACTIVITY

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

Programmierbeispiel

DELIB API Referenz |

Seite 85