Deditec USB-RELAIS-8, USB-RELAIS-8_A, USB-RELAIS-8_B, USB-OPTOIN-8, USB-OPTOIN-8_A Hardware-Description [de]

...

Download

USB-OPTOIN-X-RELAIS-X

Hardware-Beschreibung

2011

November

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

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

27 27 27

28 28 29 32

3.3.1. Digital Input-Output Demo

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

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

Einleitung

Einleitung |Seite 5

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

Hardware Beschreibung

Hardware Beschreibung |Seite 7

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

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

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

125 x 105 x 74,5

USB-OPTOIN-32

USB-RELAIS-32

USB-OPTOIN-32-RELAIS-32

230 x 105 x 74,5

USB-OPTOIN-64

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

2.4. Übersichtsbilder

2.4.1. Übersichtsbild USB-OPTOIN-8-RELAIS-8

Hardware Beschreibung |Seite 11

2.4.2. Übersichtsbild USB-OPTOIN-16-RELAIS-16

Hardware Beschreibung |Seite 12

2.4.3. Übersichtsbild USB-OPTOIN-32-RELAIS-32

Hardware Beschreibung |Seite 13

2.4.4. Übersichtsbild USB-OPTOIN-32

Hardware Beschreibung |Seite 14

2.4.5. Übersichtsbild USB-RELAIS-32

Hardware Beschreibung |Seite 15

2.4.6. Übersichtsbild USB-OPTOIN-64

Hardware Beschreibung |Seite 16

2.4.7. Übersichtsbild USB-RELAIS-64

Hardware Beschreibung |Seite 17

2.5. Pinbelegung

Belegung

Output Channel 1

Output Channel 2

Output Channel 3

Output Channel 4

Output Channel 5

Output Channel 6

Output Channel 7

Output Channel 8

2.5.1. Pinbelegung Ausgänge

Hardware Beschreibung |Seite 18

2.5.2. Pinbelegung Eingänge

Belegung

Input Channel 1

Input Channel 2

Input Channel 3

Input Channel 4

Input Channel 5

Input Channel 6

Input Channel 7

Input Channel 8

Hardware Beschreibung |Seite 19

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

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

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

Software

III

Software |Seite 23

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

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

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

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

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

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

Drücken Sie auf “Install”.

Software |Seite 30

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

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

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

Software |Seite 34

DELIB API Referenz

DELIB API Referenz |Seite 35

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Anhang

Anhang |Seite 63

5. Anhang

5.1. Revisionen

Rev 2.00 Erste DEDITEC Anleitung

Anhang |Seite 64

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

Deditec USB-RELAIS-8, USB-RELAIS-8_A, USB-RELAIS-8_B, USB-OPTOIN-8, USB-OPTOIN-8_A Hardware-Description [de]

Specifications and Main Features

Frequently Asked Questions

User Manual