Deditec USB-OPTOIN-8-RELAIS-8, USB-OPTOIN-16-RELAIS-16, USB-OPTOIN-32-RELAIS-32, USB-OPTOIN-32, USB-RELAIS-32 Hardware-Description [de]
...Page 1
USB-OPTOIN-X-RELAIS-X
Hardware-Beschreibung
2011
November
Page 2
INDEX
1. Einleitung 6
1.1. Vorwort 6
1.2. Kundenzufriedenheit 6
1.3. Kundenresonanz 6
2. Hardware Beschreibung 8
2.1. Einführung 8
2.2. Kurzanleitung Installation 9
2.2.1. Schritt 1 - Installation der Software und Treiber
2.2.2. Schritt 2 - Anschluss des Moduls
2.2.3. Schritt 3 - Test der Verbindung und des Moduls
2.3. Technische Daten 10
2.4. Übersichtsbilder 11
2.4.1. Übersichtsbild USB-OPTOIN-8-RELAIS-8
2.4.2. Übersichtsbild USB-OPTOIN-16-RELAIS-16
2.4.3. Übersichtsbild USB-OPTOIN-32-RELAIS-32
2.4.4. Übersichtsbild USB-OPTOIN-32
2.4.5. Übersichtsbild USB-RELAIS-32
2.4.6. Übersichtsbild USB-OPTOIN-64
2.4.7. Übersichtsbild USB-RELAIS-64
11
12
13
14
15
16
17
2.5. Pinbelegung 18
2.5.1. Pinbelegung Ausgänge
2.5.2. Pinbelegung Eingänge
18
19
2.6. J2 - Konfiguration der Spannungsversorgung 20
9
9
9
2.7. Ausgänge 21
2.7.1. Relais Ausgänge
2.7.2. Timeout-Schutz
2.7.3. Visuelle Kontrolle der Ausgänge
21
21
21
2.8. Eingänge 22
Index | 2Seite
Page 3
INDEX
2.8.1. Erfassen von schnellen Eingangsimpulsen
2.8.2. Galvanische Trennung durch Optokoppler
2.8.3. Visuelle Kontrolle der Eingänge
22
22
22
3. Software 24
3.1. Benutzung unserer Produkte 24
3.1.1. Ansteuerung über grafische Anwendungen
3.1.2. Ansteuerung über unsere DELIB Treiberbibliothek
3.1.3. Ansteuerung auf Protokollebene
3.1.4. Ansteuerung über mitgelieferte Testprogramme
3.2. DELIB Treiberbibliothek 26
3.2.1. Übersicht
3.2.1.1. Programmieren unter diversen
Betriebssystemen
3.2.1.2. Programmieren mit diversen
Programmiersprachen
3.2.1.3. Schnittstellenunabhängiges programmieren
3.2.1.4. SDK-Kit für Programmierer
3.2.2. Unterstützte Betriebssysteme
3.2.3. Unterstützte Programmiersprachen
3.2.4. Installation DELIB-Treiberbibliothek
3.2.5. DELIB Configuration Utility
3.3. Testprogramme 33
24
24
24
25
26
26
27
27
27
28
28
29
32
3.3.1. Digital Input-Output Demo
33
4. DELIB API Referenz 36
4.1. Verwaltungsfunktionen 36
4.1.1. DapiOpenModule
4.1.2. DapiCloseModule
4.1.3. DapiGetDELIBVersion
4.1.4. DapiSpecialCMDGetModuleConfig
36
37
38
39
4.2. Fehlerbehandlung 41
4.2.1. DapiGetLastError
4.2.2. DapiGetLastErrorText
41
42
4.3. Digitale Eingänge lesen 43
Index | 3Seite
Page 4
INDEX
4.3.1. DapiDIGet1
4.3.2. DapiDIGet8
4.3.3. DapiDIGet16
4.3.4. DapiDIGet32
4.3.5. DapiDIGet64
4.3.6. DapiDIGetFF32
4.3.7. DapiDIGetCounter
43
44
45
46
47
48
49
4.4. Digitale Ausgänge verwalten 50
4.4.1. DapiDOSet1
4.4.2. DapiDOSet8
4.4.3. DapiDOSet16
4.4.4. DapiDOSet32
4.4.5. DapiDOSet64
4.4.6. DapiDOReadback32
4.4.7. DapiDOReadback64
50
51
52
53
54
55
56
4.5. Ausgabe-Timeout verwalten 57
4.5.1. DapiSpecialCMDTimeout
4.5.2. DapiSpecialCMDTimeoutGetStatus
57
58
4.6. Programmier-Beispiel 59
5. Anhang 64
5.1. Revisionen 64
5.2. Urheberrechte und Marken 65
Index | 4Seite
Page 5
Einleitung
I
Einleitung |Seite 5
Page 6
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 6
Page 7
Hardware Beschreibung
II
Hardware Beschreibung |Seite 7
Page 8
2. Hardware Beschreibung
2.1. Einführung
Die USB-OPTOIN-X-RELAIS-X Module verfügen über Relais mit einer maximalen
Schaltspannung von 36V DC (max. 1A, 15 Watt) sowie über Opto-In Eingänge, die
sich für den industriellen Einsatz zur Erfassung von Zuständen oder auch zum
Zählen von Zustandsänderungen der Eingänge eignen.
Unsere USB Module sind für den industriellen Einsatz zur Messung, Steuerung und
Regelung entwickelt worden. Die Module verfügen alle über ein USB-Interface und
können daher an PC-Systeme mit USB-Bus angeschlossen werden. Der USB-Bus
hat sich seit vielen Jahren im Einsatz bewährt und zeichnet sich durch seine hohe
Flexibilität aus.
Als Anschlussklemmen kommen servicefreundliche Steckleisten mit
Verriegelungsschutz und Auswerfmechanik zum Einsatz. Diese ermöglichen ein
schnelles, nachträgliches Umstecken der angeschlossenen Anlagen. Der
Leitungsanschluß selbst erfolgt über ein schraubenloses Stecksystem.
Hardware Beschreibung |Seite 8
Page 9
2.2. Kurzanleitung Installation
2.2.1. Schritt 1 - Installation der Software und Treiber
Installieren Sie nun die DELIB-Treiberbibliothek mit der Datei
"delib_install.exe" von der im Lieferumfang enthaltenen DEDITEC-Treiber CD.
Diese finden Sie im Verzeichnis "\zip\delib\delib_install.exe" der DEDITECTreiber CD.
Anmerkung: Auf unserer Website http://www.deditec.de/delib finden Sie immer die
aktuellste DELIB Treiber Version.
2.2.2. Schritt 2 - Anschluss des Moduls
Verbinden Sie ihren PC per USB-Kabel mit dem USB-Anschluss des Moduls.
Nach etwa 20 Sekunden wird das Modul vom Treiber erkannt und kann nun
getestet und betrieben werden.
2.2.3. Schritt 3 - Test der Verbindung und des Moduls
Im Startmenü finden Sie unter "Start -> Alle Programme -> DEDITEC -> DELIB ->
Sample Programs" Beispiel-Programme um Ihr Modul zu testen.
Hardware Beschreibung |Seite 9
Page 10
2.3. Technische Daten
Produkt
Eingänge
Ausgänge
Länge x Breite x Höhe in mm
USB-OPTOIN-8-RELAIS-8
88102,5 x 105 x 74,5
USB-OPTOIN-16-RELAIS-16
16
16
125 x 105 x 74,5
USB-OPTOIN-32
32
-
USB-RELAIS-32
-
32
USB-OPTOIN-32-RELAIS-32
32
32
230 x 105 x 74,5
USB-OPTOIN-64
64
-
USB-RELAIS-64
-
64
USB-Interface (USB 1.1 / USB 2.0)
Spannungsversorgung: +5V (wird über USB-Bus versorgt)
8/16/32/64 Optokoppler Eingänge je nach Modul
Variabler Eingangsspannungsbereich min. 5V, max. 30V AC (Standard: 15-
30V)
Galvanisch getrennt durch Optokoppler
Erfassung von Impulsen zwischen 2 Auslesetakten
8/16/32/64 Relais Ausgänge je nach Modul (36V, 1A, 15W, Schließer-Relais)
Timeout Schutz
Galvanisch getrennt durch Relais
Betriebstemperatur: 10°C .. 50°C
Produktspezifische Daten:
Hardware Beschreibung |Seite 10
Page 11
2.4. Übersichtsbilder
2.4.1. Übersichtsbild USB-OPTOIN-8-RELAIS-8
Hardware Beschreibung |Seite 11
Page 12
2.4.2. Übersichtsbild USB-OPTOIN-16-RELAIS-16
Hardware Beschreibung |Seite 12
Page 13
2.4.3. Übersichtsbild USB-OPTOIN-32-RELAIS-32
Hardware Beschreibung |Seite 13
Page 14
2.4.4. Übersichtsbild USB-OPTOIN-32
Hardware Beschreibung |Seite 14
Page 15
2.4.5. Übersichtsbild USB-RELAIS-32
Hardware Beschreibung |Seite 15
Page 16
2.4.6. Übersichtsbild USB-OPTOIN-64
Hardware Beschreibung |Seite 16
Page 17
2.4.7. Übersichtsbild USB-RELAIS-64
Hardware Beschreibung |Seite 17
Page 18
2.5. Pinbelegung
Pin
Belegung
1a
Output Channel 1
1b
Output Channel 1
2a
Output Channel 2
2b
Output Channel 2
3a
Output Channel 3
3b
Output Channel 3
4a
Output Channel 4
4b
Output Channel 4
5a
Output Channel 5
5b
Output Channel 5
6a
Output Channel 6
6b
Output Channel 6
7a
Output Channel 7
7b
Output Channel 7
8a
Output Channel 8
8b
Output Channel 8
2.5.1. Pinbelegung Ausgänge
Hardware Beschreibung |Seite 18
Page 19
2.5.2. Pinbelegung Eingänge
Pin
Belegung
1a
Input Channel 1
1b
Input Channel 1
2a
Input Channel 2
2b
Input Channel 2
3a
Input Channel 3
3b
Input Channel 3
4a
Input Channel 4
4b
Input Channel 4
5a
Input Channel 5
5b
Input Channel 5
6a
Input Channel 6
6b
Input Channel 6
7a
Input Channel 7
7b
Input Channel 7
8a
Input Channel 8
8b
Input Channel 8
Hardware Beschreibung |Seite 19
Page 20
2.6. J2 - Konfiguration der Spannungsversorgung
Die Konfiguration der Spannungsversorgung erfolgt über einen Jumper. (J2)
Versorgung über den USB-Bus (J3) des Modules
Jumperstellung Pin 1 & 2
(+5V DC)
Anmerkung: Bei zuvielen Relais kann eine ausreichende Spannungsversorgung
über die USB-Schnittstelle nicht immer
gewährleistet werden.
Versorgung durch eine externe Spannungszufuhr (J1)
Jumperstellung Pin 2 & 3
(+7-24V DC)
Hardware Beschreibung |Seite 20
Page 21
2.7. Ausgänge
2.7.1. Relais Ausgänge
Durch den Einsatz von Relais lassen sich Spannungen von bis zu 36V schalten.
Die maximale Strombelastbarkeit beträgt 1A bei einer maximalen Schaltleistung
von 15W.
Außerdem sorgen die Relais für eine sichere galvanische Trennung des Moduls
von den angeschlossenen Anlagen.
2.7.2. Timeout-Schutz
Der Timeout-Schutz bietet die Möglichkeit die Ausgänge selbstständig
abzuschalten. Dies geschieht immer dann, wenn in einem vorher definierten
Zeitfenster keine Nachrichten mehr vom Modul empfangen werden. Gründe können
sein: Leitungsunterbrechung, PC / Serverabsturz usw. Dadurch können
Steuerungsschäden, Überlastung der angeschlossenen Anlagen und
Unfallgefahren verhindert werden.
2.7.3. Visuelle Kontrolle der Ausgänge
Über eine LED wird der Zustand jedes Ausgangs direkt angezeigt. Signale an den
Ausgängen sind somit einfacher zu erkennen und Fehler in der Verdrahtung lassen
sich dadurch schneller beheben.
Hardware Beschreibung |Seite 21
Page 22
2.8. Eingänge
2.8.1. Erfassen von schnellen Eingangsimpulsen
Schnelle Zustandswechsel an den Eingängen, die innerhalb von größeren
Auslesezyklen auftreten, werden durch eine zusätzliche Logik erfasst und können
separat per Software ausgelesen werden.
2.8.2. Galvanische Trennung durch Optokoppler
Wechselspannungs geeignete Eingangs-Optokoppler sorgen zum einem für eine
galvanische Trennung des Moduls zu den angeschlossenen Anlagen und zum
anderen verhindert man eine Beschädigung des Moduls bei verpoltem Anschluss
oder auftretenden Spannungspitzen o.ä. im Steuerstromkreis.
2.8.3. Visuelle Kontrolle der Eingänge
Über eine LED wird der Zustand jedes Eingangs direkt angezeigt. Signale an den
Eingängen sind somit einfacher zu erkennen und Fehler in der Verdrahtung lassen
sich dadurch schneller beheben.
Hardware Beschreibung |Seite 22
Page 23
Software
III
Software |Seite 23
Page 24
3. Software
3.1. Benutzung unserer Produkte
3.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!
3.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
3.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 24
Page 25
3.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 25
Page 26
3.2. DELIB Treiberbibliothek
3.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
3.2.1.1. 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 26
Page 27
3.2.1.2. 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.
3.2.1.3. 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 !
3.2.1.4. 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 27
Page 28
3.2.2. Unterstützte Betriebssysteme
Unsere Produkte unterstützen folgende Betriebssysteme:
Windows 7
Windows Vista
Windows XP
Windows 2000
Linux
3.2.3. Unterstützte Programmiersprachen
Unsere Produkte sind über folgende Programmiersprachen ansprechbar:
C
C++
C#
Delphi
VisualBasic
VB.NET
MS-Office
Software |Seite 28
Page 29
3.2.4. Installation DELIB-Treiberbibliothek
Startbild unseres DELIB Installers.
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.
Software |Seite 29
Page 30
Drücken Sie auf “Install”.
Software |Seite 30
Page 31
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 31
Page 32
3.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 32
Page 33
3.3. Testprogramme
3.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 33
Page 34
Software |Seite 34
Page 35
DELIB API Referenz
IV
DELIB API Referenz |Seite 35
Page 36
4. 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;
}
4.1. Verwaltungsfunktionen
4.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 36
Page 37
4.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 37
Page 38
4.1.3. DapiGetDELIBVersion
version = DapiGetDELIBVersion(0, 0);
//Bei installierter Version 1.32 ist version = 132(hex)
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
DELIB API Referenz |Seite 38
Page 39
4.1.4. DapiSpecialCMDGetModuleConfig
Beschreibung
Diese Funktion gibt die Hardwareaustattung (Anzahl der Ein- bzw.
Ausgangskanäle) des Moduls zurück.
Definition
ULONG DapiSpecialCommand(ULONG handle, DAPI_SPECIAL_CMD_GET_MODULE_CONFIG,
par, 0, 0);
Parameter
handle=Dies ist das Handle eines geöffneten Moduls
Anzahl der digitalen Eingangskanäle abfragen
par=DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_DI
Anzahl der digitalen Ausgangskanäle abfragen
par=DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_DO
Anzahl der digitalen Ein-/Ausgangskanäle abfragen
par=DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_DX
Anzahl der analogen Eingangskanäle abfragen
par=DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_AD
Anzahl der analogen Ausgangskanäle abfragen
par=DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_DA
Anzahl der Stepperkanäle abfragen
par=DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_STEPPER
DELIB API Referenz |Seite 39
Page 40
Return-Wert
ret=DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_GET_MODULE_CONFIG,
DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_DI, 0, 0);
//Gibt die Anzahl der digitalen Eingangskanäle zurück
ret=DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_GET_MODULE_CONFIG,
DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_DO, 0, 0);
//Gibt die Anzahl der digitalen Ausgangskanäle zurück
ret=DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_GET_MODULE_CONFIG,
DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_DX, 0, 0);
//Gibt die Anzahl der digitalen Ein-/Ausgangskanäle zurück
ret=DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_GET_MODULE_CONFIG,
DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_AD, 0, 0);
//Gibt die Anzahl der analogen Eingangskanäle zurück
ret=DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_GET_MODULE_CONFIG,
DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_DA, 0, 0);
//Gibt die Anzahl der analogen Ausgangskanäle zurück
ret=DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_GET_MODULE_CONFIG,
DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_STEPPER, 0, 0);
//Gibt die Anzahl der Stepperkanäle zurück
Anzahl der digitalen Eingangskanäle abfragen
return=Anzahl der digitalen Eingangskanäle
Anzahl der digitalen Ausgangskanäle abfragen
return=Anzahl der digitalen Ausgangskanäle
Anzahl der digitalen Ein-/Ausgangskanäle abfragen
return=Anzahl der digitalen Ein-/Ausgangskanäle
Anzahl der analogen Eingangskanäle abfragen
return=Anzahl der analogen Eingangskanäle
Anzahl der analogen Ausgangskanäle abfragen
return=Anzahl der analogen Ausgangskanäle
Anzahl der Stepperkanäle abfragen
return=Anzahl der Stepperkanäle
Programmierbeispiel
DELIB API Referenz |Seite 40
Page 41
4.2. Fehlerbehandlung
ULONG error;
error=DapiGetLastError();
if(error==0) return FALSE;
printf("ERROR = %d”, error);
4.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 41
Page 42
4.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 42
Page 43
4.3. Digitale Eingänge lesen
4.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 43
Page 44
4.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 44
Page 45
4.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 45
Page 46
4.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 46
Page 47
4.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 47
Page 48
4.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 48
Page 49
4.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
value = DapiDIGetCounter(handle, 1 , DAPI_CNT_MODE_READ_LATCHED);
// Auslesen des gespeicherten Zählerstandes von DI Chan 1
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
Angabe des Zählerwertes
Programmierbeispiel
DELIB API Referenz |Seite 49
Page 50
4.4. Digitale Ausgänge verwalten
4.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 50
Page 51
4.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 51
Page 52
4.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 52
Page 53
4.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 53
Page 54
4.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 54
Page 55
4.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 55
Page 56
4.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 56
Page 57
4.5. Ausgabe-Timeout verwalten
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT,
DAPI_SPECIAL_TIMEOUT_SET_VALUE_SEC, 3, 7);
//Die Zeit des Timeouts wird auf 3,7sek gesetzt.
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT,
DAPI_SPECIAL_TIMEOUT_ACTIVATE, 0, 0);
//Der Timeout wird aktiviert.
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT,
DAPI_SPECIAL_TIMEOUT_DEACTIVATE, 0, 0);
//Der Timeout wird deaktiviert.
4.5.1. DapiSpecialCMDTimeout
Beschreibung
Dieser Befehl dient zum Setzen der Timeout-Zeit
Definition
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT, cmd, par1, par2);
Parameter
handle=Dies ist das Handle eines geöffneten Moduls
Timeout-Zeit setzen
cmd=DAPI_SPECIAL_CMD_TIMEOUT_SET_VALUE_SEC
par1=Sekunden [s]
par2=Millisekunden [100ms] (Wert 6 bedeutet 600ms)
Timeout aktivieren setzen
cmd=DAPI_SPECIAL_CMD_TIMEOUT_ACTIVATE
Timeout deaktivieren setzen
cmd=DAPI_SPECIAL_CMD_TIMEOUT_DEACTIVATE
Return-Wert
Keiner
Programmierbeispiel
DELIB API Referenz |Seite 57
Page 58
4.5.2. DapiSpecialCMDTimeoutGetStatus
status = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT,
DAPI_SPECIAL_TIMEOUT_GET_STATUS, 0, 0);
//Abfrage des Timeout-Status.
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
handle=Dies ist das Handle eines geöffneten Moduls
Return-Wert
Return=0 (Timeout ist deaktivert)
Return=1 (Timeout ist aktiviert)
Return=2 (Timeout hat stattgefunden)
Programmierbeispiel
DELIB API Referenz |Seite 58
Page 59
4.6. Programmier-Beispiel
//****************************************************************
//****************************************************************
//****************************************************************
//****************************************************************
//****************************************************************
//
//
// product: usb-optoin-8-relais-8 (ModuleID = USB_OPTOIN_8_RELAIS_8)
// configuration: digital-outputs
// programming language: vc
//
//
// (c) DEDITEC GmbH, 2011
// web: http://www.deditec.de/
// mail: vertrieb@deditec.de
//
//
//****************************************************************
//****************************************************************
//****************************************************************
//****************************************************************
//****************************************************************
//
//
// Please include the following library on linking: delib.lib
//
// This can be done at the project settings (Project/Settings/Link ->
// Object/library modules) .. extend the existing line with the ending
// "$(DELIB_LIB)\delib.lib" (with quotation marks)
//
// Including the header file delib.h (Project/Settings/C/C++ -> select
category
// "Preprocessor" -> Additional inlude directories) .. enter the line
// "$(DELIB_INCLUDE)" (with quotation marks)
#include <windows.h>
#include <stdio.h>
#include "conio.h"
#include "delib.h"
// --------------------------------------------------------------// GetLastError function
BOOL IsError()
{
unsigned char msg[500];
if (DapiGetLastError() != DAPI_ERR_NONE)
{
DapiGetLastErrorText((unsigned char*) msg, sizeof(msg));
printf("Error Code = %x * Message = %s\n", 0, msg);
DELIB API Referenz |Seite 59
Page 60
DapiClearLastError();
return TRUE;
}
return FALSE;
}
//****************************************************************
//****************************************************************
//****************************************************************
//****************************************************************
//****************************************************************
void main(void)
{
unsigned long handle;
unsigned long value;
// ---------------------------------------------------------
// Open Module
handle = DapiOpenModule(USB_OPTOIN_8_RELAIS_8,0);
printf("Module handle = %x\n", handle);
// ---------------------------------------------------------
// Module not found!
if (handle==0)
{
printf("Could not open module!\n");
printf("Press any key to exit\n");
getch();
return;
}
// ---------------------------------------------------------
// Module found!
printf("Module has been opened\n");
// ---------------------------------------------------------
// Show config of module
value = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_GET_MODULE_CONFIG,
DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_DO, 0, 0);
IsError();
printf("Configuration of the module: no. of digital outputs %d\n",
value);
printf("Press any key to continue\n");
getch();
// ---------------------------------------------------------
// Write output channels
DELIB API Referenz |Seite 60
Page 61
DapiDOSet1(handle, 0, 1);
IsError();
printf("Output channel 0 has been switched on\n");
printf("Press any key to continue\n");
getch();
DapiDOSet1(handle, 0, 0);
IsError();
printf("Output channel 0 has been switched off\n");
printf("Press any key to continue\n");
getch();
DapiDOSet1(handle, 1, 1);
IsError();
printf("Output channel 1 has been switched on\n");
printf("Press any key to continue\n");
getch();
DapiDOSet1(handle, 1, 0);
IsError();
printf("Output channel 1 has been switched off\n");
printf("Press any key to continue\n");
getch();
DapiDOSet8(handle, 0, 0xff); //hexadecimal
IsError();
printf("Output channel 0-7 have been switched on\n");
printf("Press any key to continue\n");
getch();
DapiDOSet8(handle, 0, 0);
IsError();
printf("Output channel 0-7 have been switched off\n");
printf("Press any key to continue\n");
getch();
// ----------------------------------------------------------
// Write and readback output channels
DapiDOSet8(handle, 0, 31);
IsError();
printf("Output channel 0-7 have been switched on\n");
printf("Press any key to continue\n");
getch();
value = DapiDOReadback32(handle, 0);
IsError();
printf("Readback output channel 0-3\n");
printf("value = %d\n", value);
printf("Press any key to continue\n");
getch();
DapiDOSet8(handle, 0, 0);
IsError();
printf("Output channel 0-7 have been switched off\n");
printf("Press any key to continue\n");
DELIB API Referenz |Seite 61
Page 62
getch();
value = DapiDOReadback32(handle, 0);
IsError();
printf("Readback output channel 0-3\n");
printf("value = %d\n", value);
printf("Press any key to continue\n");
getch();
// ----------------------------------------------------------
// Set timeout of output channels to 5 seconds
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT,
DAPI_SPECIAL_TIMEOUT_SET_VALUE_SEC, 5, 0);
IsError();
printf("Timeout has been set to 5 seconds\n");
printf("Press any key to continue\n");
getch();
// ---------------------------------------------------------// Activate timeout and switch on output channels 0-3
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT,
DAPI_SPECIAL_TIMEOUT_ACTIVATE, 0, 0);
IsError();
DapiDOSet8(handle, 0, 15);
IsError();
printf("Timeout has been activated\n");
printf("Output channels 0-3 have been switched on and will be switched
off automatically after 5 seconds\n");
printf("Press any key to continue\n");
getch();
// ---------------------------------------------------------// Deactivate timeout
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_TIMEOUT,
DAPI_SPECIAL_TIMEOUT_DEACTIVATE, 0, 0);
IsError();
printf("Timeout has been deactivated\n");
printf("Press any key to continue\n");
getch();
// ---------------------------------------------------------// Close Module
DapiCloseModule(handle);
printf("Module closed\n");
printf("End of program!\n");
printf("Press any key to exit\n");
getch();
return ;
}
DELIB API Referenz |Seite 62
Page 63
Anhang
V
Anhang |Seite 63
Page 64
5. Anhang
5.1. Revisionen
Rev 2.00 Erste DEDITEC Anleitung
Anhang |Seite 64
Page 65
5.2. 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 65
Loading...