8*TTL-Ein-/Ausgänge über den USB Bus steuern und abfragen

0 Kundenrezensionen

 98,18

Verfügbarkeit: Auf Lager SKU: USB-MINI-TTL8 Kategorie:

Nutzen Sie unsere Vorteile

Lebenslange
Updates

Kostenlose Soft- & Hardware(Firmware)-Updates.
Genießen Sie unseren lebenslangen Update-Service.

5 Jahre
Lieferverfügbarkeit

Wir bieten für unsere Produkte mindestens 5 Jahre Lieferverfügbarkeit.
Unsere Erfahrung zeigt dass es sogar ungefähr 10 Jahre sind.

Fragen zum Produkt? Produktberatung

Haben Sie vor dem Kauf noch technische oder kaufmännische Fragen zum Produkt?
Kontaktieren Sie uns dazu gerne vorab.

Kunden-
Modifikationen

Unsere Produkte dienen oft als Basis für Kundenspeziallösungen.
Sprechen Sie uns einfach an.

Wir sind
Immer für Sie da!

Seit der Gründung 2008 ist Dipl. Ing. Jürgen Siebert Geschäftsführer der DEDITEC GmbH. Gerne berät er Sie auch persönlich.

Produkt- & Service-Hotline: +49 (0) 22 32 / 50 40 8 – 40 Fragen zum Produkt oder zur Bestellung: support@deditec.de

Der USB-MINI-TTL8 Stick ist das kleinste I/O Modul unserer Produktpalette. Er findet dort Einsatz, wo über den USB-Bus direkt auf TTL-Ein- bzw. Ausgänge zugegriffen werden soll.

  • 8*TTL-Ein-Ausgänge
  • 5V TTL -Pegel
  • LED Zugriffsanzeige auf den USB-Stick

Software und Ansteuerung

Durch unsere mitgelieferte DELIB Treiberbibliothek ist ein einfaches Ansprechen des Produkts über unsere API möglich.

 

Wir bieten Support für folgende Programmiersprachen:

  • C
  • C++
  • C#
  • VB
  • VBA
  • VB.Net
  • Java
  • Delphi
  • LabVIEW

Wir bieten Support für folgende Betriebssysteme:

  • Windows 10 (32bit/64bit)
  • Windows 8/8.1 (32bit/64bit)
  • Windows 7 (32bit/64bit)
  • Windows Vista (32bit/64bit)
  • Windows XP (32bit/64bit)
  • Windows Server 2003 (32bit/64bit)
  • Windows 2000
  • Linux

Entsprechende Programmierbeispiele finden Sie bei den Produkten im Bereich “Software” oder sind als Lieferumfang auf der Treiber CD enthalten.


Allgemein

Versorgungsspannung +5V (via USB-Port)
Interface USB 2.0 / USB 1.1
Zugriffsgeschwindigkeit Durchschnittliche Zugriffszeit vom PC auf das Modul: 0,4 ms
(Berechnet mit 1000 Zugriffen auf das Modul über die DELIB Treiberbibliothek mit dem Befehl DapiDoSet32)
LEDs Signalisiert Zugriff auf den USB-Stick
Ein-/Ausgänge • Anzahl: 8 (per Software als Eingang oder Ausgang setzbar)
• 5V TTL Pegel
• max. 5mA / Kanal
Anschlusskabel ca. 1,8m an 9 pol. D-Sub Buchse
Betriebstemperatur +10°C bis +50°C
Abmessungen 84,5 x 21 x 12,5/9,5 mm (ohne Kabel)

 

Zusätzliche Informationen

Gewicht 81 kg

Konfiguration

Konfiguration von USB-Modulen

Produkte mit USB-Schnittstelle werden selbstständig von der DELIB Treiberbibliothek erkannt. Eine Konfiguration muss nur vorgenommen werden, falls mehrere identische USB-Produkte am selben System eingesetzt werden sollen.

 


Mehrere identische USB-Module an einem System

Jedes unserer USB Produkte hat im Auslieferungszustand die Modul-Nr “0”. Beim Einsatz von mehr als einem USB Modul an einem PC / System, muss zunächst jedem weiteren Modul eine neue Modul Nr. zugewiesen werden. Diese Zuweisung geschieht mit Hilfe unseres DELIB-Configuration Utility. Nur so kann softwareseitig eine eindeutige Zuordnung stattfinden. Die Modul-Nr wird fest im Produkt gespeichert. Es können bis zu 255 identische Module an einem System verwendet werden.


Nähere Details zur Ansteuerung sowie einige Programmierbeispiele, finden Sie im Bereich Programmierung.

Verwaltungsfunktionen

DapiOpenModule
Diese Funktion öffnet ein bestimmtes Modul.

DapiOpenModule

Beschreibung

Diese Funktion öffnet ein bestimmtes Modul

 

Definition

ULONG DapiOpenModule(ULONG moduleID, ULONG nr);

 

Parameter

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

 

Return-Wert

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

 

Bemerkung

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

 

Programmierbeispiel

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

DapiCloseModule
Dieser Befehl schliesst ein geöffnetes Modul.

DapiCloseModule

Beschreibung

Dieser Befehl schliesst ein geöffnetes Modul.

 

Definition

ULONG DapiCloseModule(ULONG handle);

 

Parameter

handle=Dies ist das Handle eines geöffneten Moduls

 

Return-Wert

Keiner

 

Programmierbeispiel

// Modul schliessen
DapiCloseModule(handle);

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

DapiGetLastError

 

Beschreibung

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

 

Definition

ULONG DapiGetLastError(void);

 

Parameter

Keine

 

Return-Wert

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

 

Programmierbeispiel

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

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

DapiClearLastError();

return TRUE;
}

return FALSE;
}

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

DapiGetLastErrorByHandle

 

Beschreibung

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

 

Definition

ULONG DapiGetLastErrorByHandle(ULONG handle);

 

Parameter

handle=Dies ist das Handle eines geöffneten Moduls

 

Return-Wert

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

 

Programmierbeispiel

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

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

DapiClearLastErrorByHandle(handle);

return TRUE;
}

return FALSE;
}

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

DapiGetLastErrorText

 

Beschreibung

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

 

Definition

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

 

Parameter

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

 

Programmierbeispiel

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

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

DapiClearLastError();

return TRUE;
}

return FALSE;
}

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

DapiClearLastError

Beschreibung

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

 

Definition

void DapiGetLastError(void);

 

Parameter

Keine

 

Return Wert

Keine

 

Beispiel-Programm

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

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

DapiClearLastError();

return TRUE;
}

return FALSE;
}

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

DapiClearLastErrorByHandle

 

Beschreibung

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

 

Definition

void DapiClearLastErrorByHandle(ULONG handle);

 

Parameter

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

 

Return Wert

Keine

 

Beispiel-Programm

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

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

DapiClearLastErrorByHandle(handle);

return TRUE;
}

return FALSE;
}

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

DapiGetDELIBVersion

 

Beschreibung

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

 

Definition

ULONG DapiGetDELIBVersion(ULONG mode, ULONG par);

 

Parameter

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

 

Return-Wert

version=Versionsnummer der installierten DELIB-Version [hex]

 

Programmierbeispiel

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

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

DapiOpenModuleEx

 

Beschreibung

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

 

Definition

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

 

Parameter

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

 

Return-Wert

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

 

Bemerkung

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

 

Programmierbeispiel

// Open ETH-Module with parameter

DAPI_OPENMODULEEX_STRUCT open_buffer;

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

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

Digitale Eingabe-Funktionen

DapiDIGet1
Dieser Befehl liest einen einzelnen digitalen Eingang

DapiDIGet1

 

Beschreibung

Dieser Befehl liest einen einzelnen digitalen Eingang.

 

Definition

ULONG DapiDIGet1(ULONG handle, ULONG ch);

 

Parameter

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

 

Return-Wert

Zustand des Eingangs (0/1)

 

Anforderungen

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

DAPI_SW_FEATURE_BIT_CFG_DI

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

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

DapiDIGet8
Dieser Befehl liest gleichzeitig 8 digitale Eingänge

DapiDIGet8

 

Beschreibung

Dieser Befehl liest gleichzeitig 8 digitale Eingänge.

 

Definition

ULONG DapiDIGet8(ULONG handle, ULONG ch);

 

Parameter

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

 

Return-Wert

Zustand der gelesen Eingänge

 

Anforderungen

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

DAPI_SW_FEATURE_BIT_CFG_DI

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

maxCh = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_GET_MODULE_CONFIG, DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_DI, 0, 0);
maxCh > ch ch must be 0, 8, 16, …

DapiDIGet16
Dieser Befehl liest gleichzeitig 16 digitale Eingänge

DapiDIGet16

 

Beschreibung

Dieser Befehl liest gleichzeitig 16 digitale Eingänge.

 

Definition

ULONG DapiDIGet16(ULONG handle, ULONG ch);

 

Parameter

handle=Dies ist das Handle eines geöffneten Moduls
ch=Gibt die Nummer des Eingangs an, ab dem gelesen werden soll (0, 16, 32, …)

 

Return-Wert

Zustand der gelesen Eingänge

 

Anforderungen

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

DAPI_SW_FEATURE_BIT_CFG_DI

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

maxCh = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_GET_MODULE_CONFIG, DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_DI, 0, 0);
maxCh > ch ch must be 0, 16, 32, …

DapiDIGet32
Dieser Befehl liest gleichzeitig 32 digitale Eingänge

DapiDIGet32

 

Beschreibung

Dieser Befehl liest gleichzeitig 32 digitale Eingänge.

 

Definition

ULONG DapiDIGet32(ULONG handle, ULONG ch);

 

Parameter

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

Return-Wert

Zustand der gelesen Eingänge

 

Anforderungen

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

DAPI_SW_FEATURE_BIT_CFG_DI

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

maxCh = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_GET_MODULE_CONFIG, DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_DI, 0, 0);
maxCh > ch ch must be 0, 32, 64, …

 

Programmierbeispiel

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

DapiDIGet64
Dieser Befehl liest gleichzeitig 64 digitale Eingänge

DapiDIGet64

 

Beschreibung

Dieser Befehl liest gleichzeitig 64 digitale Eingänge.

 

Definition

ULONGLONG DapiDIGet64(ULONG handle, ULONG ch);

 

Parameter

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

 

Return-Wert

Zustand der gelesen Eingänge

 

Anforderungen

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

DAPI_SW_FEATURE_BIT_CFG_DI

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

maxCh = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_GET_MODULE_CONFIG, DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_DI, 0, 0);
maxCh > ch ch must be 0 or 64

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

DapiDIGetFF32

 

Beschreibung

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

 

Definition

ULONG DapiDIGetFF32(ULONG handle, ULONG ch);

 

Parameter

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

 

Return-Wert

Zustand von 32 Eingangszustandsänderungen

 

Anforderungen

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

DAPI_SW_FEATURE_BIT_CFG_DI_FF

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

maxCh = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_GET_MODULE_CONFIG, DAPI_SPECIAL_GET_MODULE_CONFIG_PAR_DI_FF, 0, 0);
maxCh > ch ch must be 0, 32, 64, …

Digitale Eingabe-Counter

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

DapiDIGetCounter

 

Beschreibung

Dieser Befehl liest den Eingangszähler eines digitalen Eingangs.

 

Definition

ULONG DapiDIGetCounter(ULONG handle, ULONG ch, ULONG mode);

 

Parameter

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

 

Return-Wert

Ausgabe des Zählerwertes

 

Requirements

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

 

DAPI_SW_FEATURE_BIT_CFG_DI_CNT

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

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

 

Programmierbeispiel

value = DapiDIGetCounter(handle, 0 ,0); // Zähler von DI Chan 0 wird gelesen
value = DapiDIGetCounter(handle, 1 ,0); // Zähler von DI Chan 1 wird gelesen
value = DapiDIGetCounter(handle, 8 ,0); // Zähler von DI Chan 8 wird gelesen
value = DapiDIGetCounter(handle, 0 ,DAPI_CNT_MODE_READ_WITH_RESET); // Zähler von DI Chan 0 wird gelesen UND resettet
value = DapiDIGetCounter(handle, 1, DAPI_CNT_MODE_READ_LATCHED); // Auslesen des gespeicherten Zählerstandes von DI Chan 1

DapiSpecialCommand - DapiSpecialCounterLatchAll
Dieser Befehl speichert die Zählerstände aller Eingangszähler gleichzeitig in ein Zwischenspeicher (Latch). So können anschließend alle Zählerstände des Latches nacheinander ausgelesen werden. Besonderheit hierbei ist, dass ein gleichzeitiges "Einfrieren" der Zählerstände möglich ist und die Eingefrorenen Stände (Latch) dann einzeln nacheinander ausgelesen werden können.

DapiSpecialCommand – DapiSpecialCounterLatchAll

 

Beschreibung

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

 

Definition

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

 

Parameter

 

Bemerkung

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

 

Programmierbeispiel

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

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

DapiSpecialCommand – DapiSpecialCounterLatchAllWithReset

 

Beschreibung

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

 

Definition

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

 

Parameter

 

Bemerkung

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

 

Programmierbeispiel

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

Digitale Ausgabe-Funktionen

DapiDOSet1
Dieser Befehl setzt einen einzelnen Ausgang.

DapiDOSet1

 

Beschreibung

Dieser Befehl setzt einen einzelnen Ausgang.

 

Definition

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

 

Parameter

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

 

Return-Wert

Keiner

 

Anforderungen

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

 

DAPI_SW_FEATURE_BIT_CFG_DO

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

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

DapiDOSet8
Dieser Befehl setzt gleichzeitig 8 digitale Ausgänge.

DapiDOSet8

 

Beschreibung

Dieser Befehl setzt gleichzeitig 8 digitale Ausgänge.

 

Definition

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

 

Parameter

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

 

Return-Wert

Keiner

DapiDOSet16
Dieser Befehl setzt gleichzeitig 16 digitale Ausgänge.

DapiDOSet16

 

Beschreibung

Dieser Befehl setzt gleichzeitig 16 digitale Ausgänge.

 

Definition

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

 

Parameter

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

 

Return-Wert

Keiner

DapiDOSet32
Dieser Befehl setzt gleichzeitig 32 digitale Ausgänge.

DapiDOSet32

 

Beschreibung

Dieser Befehl setzt gleichzeitig 32 digitale Ausgänge.

 

Definition

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

 

Parameter

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

 

Return-Wert

Keiner

 

Programmierbeispiel

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

DapiDOSet64
Dieser Befehl setzt gleichzeitig 64 digitale Ausgänge.

DapiDOSet64

 

Beschreibung

Dieser Befehl setzt gleichzeitig 64 digitale Ausgänge.

 

Definition

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

 

Parameter

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

 

Return-Wert

Keiner

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

DapiDOClrBit32

 

Beschreibung

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

 

Definition

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

 

Parameter

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

 

Return-Wert

Keiner

 

Bemerkung

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

 

Programmierbeispiel

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

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

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

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

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

DapiDOSet1_WithTimer

 

Beschreibung

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

 

Definition

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

 

Parameter

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

 

Return-Wert

Keiner

 

Bemerkung

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

 

Programmierbeispiel

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

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

DapiDOSetBit32

 

Beschreibung

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

 

Definition

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

 

Parameter

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

 

Return-Wert

Keiner

 

Bemerkung

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

 

Programmierbeispiel

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

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

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

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

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

DapiDOReadback32

 

Beschreibung

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

 

Definition

ULONG DapiDOReadback32(ULONG handle, ULONG ch);

 

Parameter

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

 

Return-Wert

Zustand von 32 Ausgängen.

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

DapiDOReadback32

 

Beschreibung

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

 

Definition

ULONG DapiDOReadback32(ULONG handle, ULONG ch);

 

Parameter

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

 

Return-Wert

Zustand von 32 Ausgängen.

TTL-Funktionen

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

DapiSpecialCommand – DapiSpecialCMDSetDirDX_1

 

Beschreibung

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

 

Definition

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

 

Parameter

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

 

Return-Wert

Keiner

 

Bemerkung

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

 

Programmierbeispiel

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

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SET_DIR_DX_1, 0, 0x0f , 0);
// Set Dir of TTL-I/O CH0-3 to output, others to input
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_SET_DIR_DX_1, 0, 0xff , 0);
// Set Dir of TTL-I/O CH0-7 to output, others to input

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

DapiSpecialCommand – DapiSpecialCMDSetDirDX_8

 

Beschreibung

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

 

Definition

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

 

Parameter

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

 

Return-Wert

Keiner

 

Bemerkung

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

 

Programmierbeispiel

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

Software FIFO-Funktionen

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

DapiSpecialCommand-DapiSpecialCMDSWFifo

 

Beschreibung

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

 

Definition

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

 

Parameter

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

 

Bemerkung

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

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

DapiSpecialCommand-DapiSpecialSWFifoSetSubmodule

 

Beschreibung

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

 

Definition

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

 

Parameter

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

 

Programmierbeispiel

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

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

DapiSpecialCommand-DapiSpecialSWFifoGetSubmodule

 

Beschreibung

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

 

Definition

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

 

Parameter

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

 

Return-Wert

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

 

Programmierbeispiel

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

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

DapiSpecialCommand-DapiSpecialSWFifoActivate

 

Beschreibung

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

 

Definition

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

 

Parameter

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

 

Programmierbeispiel

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

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

DapiSpecialCommand-DapiSpecialSWFifoDeactivate

 

Beschreibung

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

 

Definition

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

 

Parameter

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

 

Programmierbeispiel

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

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

DapiSpecialCommand-DapiSpecialSWFifoGetActivity

 

Beschreibung

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

 

Definition

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

 

Parameter

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

 

Return-Wert

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

 

Programmierbeispiel

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

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

DapiSpecialCommand-DapiSpecialSWFifoIOActivate

 

Beschreibung

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

 

Definition

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

 

Parameter

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

 

Programmierbeispiel

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

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

DapiSpecialCommand-DapiSpecialSWFifoIODeactivate

 

Beschreibung

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

 

Definition

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

 

Parameter

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

Programmierbeispiel

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

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

DapiSpecialCommand-DapiSpecialSWFifoInitAndClear

 

Beschreibung

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

 

Definition

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

 

Parameter

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

 

Programmierbeispiel

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

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

DapiSpecialCommand-DapiSpecialSWFifoSetChannel

 

Beschreibung

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

 

Definition

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

 

Parameter

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

 

Programmierbeispiel

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

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

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

DapiSpecialCommand-DapiSpecialSWFifoGetChannel

 

Beschreibung

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

 

Definition

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

 

Parameter

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

 

Return-Wert

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

 

Programmierbeispiel

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

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

DapiSpecialCommand-DapiSpecialSWFifoSetFrequencyHz

 

Beschreibung

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

 

Definition

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

 

Parameter

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

 

Programmierbeispiel

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

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

DapiSpecialCommand-DapiSpecialSWFifoGetFrequencyHz

 

Beschreibung

Dieser Befehl gibt das vorher eingestellte Frequenzintervall in Hertz wieder.

 

Definition

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

 

Parameter

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

 

Return-Wert

Frequenzintervall in Hertz (Hz)

 

Programmierbeispiel

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

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

DapiSpecialCommand-DapiSpecialSWFifoGetBytesFree

 

Beschreibung

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

 

Definition

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

 

Parameter

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

 

Return-Wert

Freie Bytes des Software FIFO

 

Programmierbeispiel

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

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

DapiSpecialCommand-DapiSpecialSWFifoGetBytesPerSample

 

Beschreibung

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

 

Definition

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

 

Parameter

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

 

Return-Wert

Benötigte Bytes pro Sample

 

Programmierbeispiel

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

DapiSpecialCommand - DapiSpecialSWFifoSetMode
Dieser Befehl setzt den Software FIFO Mode

DapiSpecialCommand-DapiSpecialSWFifoSetMode

 

Beschreibung

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

 

Definition

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

 

Parameter

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

 

Programmierbeispiel

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

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

DapiSpecialCommand-DapiSpecialSWFifoGetMode

 

Beschreibung

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

 

Definition

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

 

Parameter

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

 

Return-Wert

FIFO Software Mode

 

Programmierbeispiel

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

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

DapiSpecialCommand-DapiSpecialSWFifoGetStatus

 

Beschreibung

Mit diesem Befehl können Statuswerte abgerufen werden.

 

Definition

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

 

Parameter

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

 

Return-Wert

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

Programmierbeispiel

unsigned long ret;

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

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

DapiSpecialCommand-DapiSpecialCMDAD

 

Beschreibung

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

 

Definition

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

 

Parameter

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

 

FIFO initialisieren

cmd=DAPI_SPECIAL_RO_AD_FIFO_INIT
par0=nicht definiert

FIFO aktivieren
cmd=DAPI_SPECIAL_RO_AD_FIFO_ACTIVATE
par0=nicht definiert

FIFO deaktivieren
cmd=DAPI_SPECIAL_RO_AD_FIFO_DEACTIVATE
par0=nicht definiert

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

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

FIFO Status abfragen
cmd=DAPI_SPECIAL_RO_AD_FIFO_GET_STATUS
par0=nicht definiert

 

Return-Wert

cmd=DAPI_SPECIAL_RO_AD_FIFO_INIT
kein return Wert

cmd=DAPI_SPECIAL_RO_AD_FIFO_ACTIVATE
kein return Wert

cmd=DAPI_SPECIAL_RO_AD_FIFO_DEACTIVATE
kein return Wert

cmd=DAPI_SPECIAL_RO_AD_FIFO_SET_INTERVAL_MS
kein return Wert

cmd=DAPI_SPECIAL_RO_AD_FIFO_SET_CHANNEL
kein return Wert

cmd=DAPI_SPECIAL_RO_AD_FIFO_GET_STATUS
return=aktueller FIFO-Status

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

 

Programmierbeispiel

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

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

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

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

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

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

DapiWriteFifo
Dieser Befehl schreibt Datensätze in den Software FIFO

DapiWriteFifo

 

Beschreibung

Dieser Befehl schreibt Datensätze in den Software FIFO.

 

Definition

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

 

Parameter

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

 

Programmierbeispiel

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

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

DapiReadFifo

 

Beschreibung

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

 

Definition

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

 

Parameter

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

 

Return-Wert

Länge der ausgelesenen FIFO-Datenstätze

 

Aufbau eines FIFO-Datensatz

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

Byte || Bedeutung || Wert [hex]

0 RO_FIFO_ID_START 0xf0

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

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

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

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

 

RO_FIFO_ID_START

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

 

FIFO Typ

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

 

Zeitstempel

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

 

Aktive A/D-Kanäle

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

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

 

Bemerkung

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

 

Programmierbeispiel

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

CNT48-Funktionen

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

DapiCnt48ModeSet

 

Beschreibung

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

 

Definition

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

 

Parameter

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

 

Mögliche Werte für mode

mode=DAPI_CNT48_MODE_COUNT_RISING_EDGE | DAPI_CNT48_SUBMODE_NO_RESET
In diesem Modus wird bei steigender Flanke gezählt.

 

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

 

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

 

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

 

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

 

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

 

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

 

Zusätzlich können alle Eingangszähler mit einem Eingangsfilter (mit einer oder-Verknüpfung) kombiniert werden. Hierzu stehen folgende Eingangsfilter zur Verfügung:

 

DAPI_CNT48_FILTER_20ns
DAPI_CNT48_FILTER_100ns
DAPI_CNT48_FILTER_250ns
DAPI_CNT48_FILTER_500ns
DAPI_CNT48_FILTER_1us
DAPI_CNT48_FILTER_2_5us
DAPI_CNT48_FILTER_5us
DAPI_CNT48_FILTER_10us
DAPI_CNT48_FILTER_25us
DAPI_CNT48_FILTER_50us
DAPI_CNT48_FILTER_100us
DAPI_CNT48_FILTER_250us
DAPI_CNT48_FILTER_500us
DAPI_CNT48_FILTER_1ms
DAPI_CNT48_FILTER_2_5ms
DAPI_CNT48_FILTER_5ms

 

Bemerkung

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

 

Programmierbeispiel

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

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

DapiCnt48ModeGet

 

Beschreibung

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

 

Definition

ULONG DapiCnt48ModeGet(ULONG handle, ULONG ch);

 

Parameter

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

 

Return-Wert

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

 

Bemerkung

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

 

Programmierbeispiel

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

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

DapiCnt48CounterGet32

 

Beschreibung

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

 

Definition

ULONG DapiCnt48CounterGet32(ULONG handle, ULONG ch);

 

Parameter

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

 

Return-Wert

Ausgabe des Zählerwertes.

 

Bemerkung

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

 

Programmierbeispiel

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

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

DapiCnt48CounterGet48

 

Beschreibung

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

 

Definition

ULONGLONG DapiCnt48CounterGet48(ULONG handle, ULONG ch);

 

Parameter

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

 

Return-Wert

Ausgabe des Zählerwertes.

 

Bemerkung

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

 

Programmierbeispiel

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

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

DapiSpecialCommand – Dapi_Special_DI_Filter_Value_Set

 

Beschreibung

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

 

Definition

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_DI, DAPI_SPECIAL_DI_FILTER_VALUE_SET, ULONG time_ms, 0);

 

Parameter

handle=Dies ist das Handle eines geöffneten Moduls
time_ms=Zeitintervall [ms], indem digitale Eingangskanäle abgetastet werden.

 

Bemerkung

Dieser Befehl unterstützt nur Impulszeiten zwischen 5ms und 255ms.
Wird keine Zeit gesetzt, ist der Default-Wert 100ms.
Dieser Befehl wird nicht von unseren Modulen mit Ethernet-Schnittstelle unterstützt

 

Programmierbeispiel

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_DI, DAPI_SPECIAL_DI_FILTER_VALUE_SET, 5, 0);
// Setzt das Zeitintervall auf 5ms
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_DI, DAPI_SPECIAL_DI_FILTER_VALUE_SET, 150, 0);
// Setzt das Zeitintervall auf 150ms

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

DapiSpecialCommand – Dapi_Special_DI_Filter_Value_Get

 

Beschreibung

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

 

Definition

ULONG DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_DI, DAPI_SPECIAL_DI_FILTER_VALUE_GET, 0, 0);

 

Parameter

handle=Dies ist das Handle eines geöffneten Moduls

 

Return-Wert

Zeit [ms]

 

Bemerkung

Dieser Befehl wird nicht von unseren Modulen mit Ethernet-Schnittstelle unterstützt.

 

Programmierbeispiel

value = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_DI, DAPI_SPECIAL_DI_FILTER_VALUE_GET, 0, 0);
//Gibt das Zeitintervall zum Abtasten der digitalen Eingangskanäle zurück.

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

DapiSpecialCommand – Dapi_Special_DI_FF_Filter_Value_Set

 

Beschreibung

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

 

Definition

void DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_DI, DAPI_SPECIAL_DI_FF_FILTER_VALUE_SET, ULONG time_ms, 0);

 

Parameter

handle=Dies ist das Handle eines geöffneten Moduls
time_ms=Zeitintervall [ms], indem digitale Eingangskanäle abgetastet werden.

 

Bemerkung

Dieser Befehl unterstützt nur Impulszeiten zwischen 5ms und 255ms.
Wird keine Zeit gesetzt, ist der Default-Wert 100ms.

 

Dieser Befehl wird nicht von unseren Modulen mit Ethernet-Schnittstelle unterstützt.

 

Programmierbeispiel

DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_DI, DAPI_SPECIAL_DI_FF_FILTER_VALUE_SET, 5, 0);
// Setzt das Zeitintervall auf 5ms
DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_DI,
DAPI_SPECIAL_DI_FF_FILTER_VALUE_SET, 150, 0);
// Setzt das Zeitintervall auf 150ms

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

DapiSpecialCommand – Dapi_Special_DI_FF_Filter_Value_Get

 

Beschreibung

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

 

Definition

ULONG DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_DI, DAPI_SPECIAL_DI_FF_FILTER_VALUE_GET, 0, 0);

 

Parameter

handle=Dies ist das Handle eines geöffneten Moduls

 

Return-Wert

Zeit [ms]

 

Bemerkung

Dieser Befehl wird nicht von unseren Modulen mit Ethernet-Schnittstelle unterstützt.

 

Programmierbeispiel

value = DapiSpecialCommand(handle, DAPI_SPECIAL_CMD_DI, DAPI_SPECIAL_DI_FF_FILTER_VALUE_GET, 0, 0);
//Gibt das Zeitintervall zum Abtasten der digitalen Eingangskanäle zurück.

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

DapiSpecialCommand – DapiSpecialCNT48LatchGroup8

 

Beschreibung

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

 

Definition

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

 

Parameter

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

 

Bemerkung

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

Bitte beachten Sie, dass nur die Zählerstände der Eingangszähler gelatched werden, bei denen zuvor der Modus

“DAPI_CNT48_SUBMODE_LATCH_COMMON” gesetzt wurde. (-> DapiCnt48ModeSet)

 

Programmierbeispiel

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

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

DapiSpecialCommand – DapiSpecialCNT48ResetGroup8

 

Beschreibung

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

 

Definition

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

 

Parameter

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

 

Bemerkung

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

 

Programmierbeispiel

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

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

DapiSpecialCommand – DapiSpecialCNT48ResetSingle

 

Beschreibung

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

 

Definition

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

 

Parameter

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

 

Bemerkung

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

 

Programmierbeispiel

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

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

DapiSpecialCommand – DapiSpecialCNT48DIGet1

 

Beschreibung

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

 

Definition

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

 

Parameter

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

 

Return-Wert

Zustand des Eingangszählers (0/1)

 

Bemerkung

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

 

Programmierbeispiel

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

In dem Blockschaltbild wird deutlich, wie der Stick an den PC angeschlossen wird.

USB-MINI-TTL8

Manual

Handbuch USB-Mini-Sticks
Hardware- und Software-Beschreibung
Download

DELIB Treiberbibliothek

Manual der DELIB Treiberbibliothek
Dokumentation aller Befehle für die Treiberbibliothek
Download
  • Windows 10, 8, Vista, 7, XP, 2000 und Linux
  • Modul open/close Funktionen
  • Digitale Eingänge: Lesen von 1 / 8 / 16 / 32 / 64 bit
  • Digitale Ausgänge: Schreiben von 1 / 8 / 16 / 32 / 64 bit
  • A/D Lesen: read, read_volt, read_mA, set A/D mode
  • D/A schreiben: write, write_volt, write_mA, set D/A mode
DELIB (64-Bit)Treiberbibliothek für Windows
Für Windows 10, Windows 7, Windows 8, Vista, XP und 2000
Download

Installationsdatei für die 64-Bit Version der DELIB Treiberbibliothek.

Die folgenden Betriebssysteme sind kompatibel:
64-Bit

  • Windows 10 x64
  • Windows 7 x64
  • Windows 8 x64
  • Windows Server 2012 x64
  • Windows Server 2008 x64
  • Windows Vista x64
  • Windows XP x64
  • Windows Server 2003 x64

Mitgelieferte Software

  • DT-Flasher x64
    Software um DEDITEC Modul auf den neusten Stand zu bringen
  • DELIB Configuration Utility x64
    Konfiguration von Moduladressen einstellen
  • DELIB Module Config x64
    Konfiguration von modulspezifischen Einstellungen
  • CAN Configuration Utility x64
    Konfiguration von CAN Modulen einstellen
  • DELIB Module Demo x64
    Ermöglicht manuelles Schalten eines Moduls
  • DELIB Command Line Interface x64
    Ermöglicht das Ausführen von DELIB-Befehlen in der Kommandozeile
  • Watchdog Configuration Utility x64
    Konfiguration eines Watchdog-Sticks einstellen
DELIB (32-Bit)Treiberbibliothek für Windows
Für Windows 10, Windows 7, Windows 8, Vista, XP und 2000
Download

Installationsdatei für die 32-Bit Version der DELIB Treiberbibliothek.

Die folgenden Betriebssysteme sind kompatibel:
32-Bit

    • Windows 10
    • Windows 7
    • Windows 8
    • Windows Server 2012
    • Windows Server 2008
    • Windows Vista
    • Windows XP
    • Windows Server 2003

64-Bit

  • Windows 10 x64
  • Windows 7 x64
  • Windows 8 x64
  • Windows Server 2012 x64
  • Windows Server 2008 x64
  • Windows Vista x64
  • Windows XP x64
  • Windows Server 2003 x64

Mitgelieferte Software

  • DT-Flasher
    Software um DEDITEC Modul auf den neusten Stand zu bringen
  • DELIB Configuration Utility
    Konfiguration von Moduladressen einstellen
  • DELIB Module Config
    Konfiguration von modulspezifischen Einstellungen
  • CAN Configuration Utility
    Konfiguration von CAN Modulen einstellen
  • DELIB Module Demo
    Ermöglicht manuelles Schalten eines Moduls
  • DELIB Command Line Interface
    Ermöglicht das Ausführen von DELIB-Befehlen in der Kommandozeile
  • Watchdog Configuration Utility
    Konfiguration eines Watchdog-Sticks einstellen

Achtung:

Mit dieser Version der Treiberbibliothek können nur 32-Bit Anwendungen erstellt werden, die dann auf 32- und 64-Bit Systemen ausgeführt werden können.

DELIB Treiberbibliothek für Linux (32/64-Bit)
Für 32/64-Bit Linux-Distributionen ab Kernel 2.6.x
Download

DELIB Treiberbibliothek für Linux-Distributionen (32/64-Bit) ab Kernel 2.6.x

Dieses Treiberpaket beinhaltet folgende Komponenten

  • DELIB USB Treiber
  • DELIB Ethernet Treiber
  • DELIB CLI

DELIB USB Treiber

Unterstützung für folgende Produkte:

  • NET-Serie (über USB Schnittstelle)
  • RO-USB-Serie
  • BS-USB-Serie
  • USB-Mini-Sticks
  • USB-Watchdog
  • USB-OPTION-8 / USB-RELAIS-8
  • USB-TTL-32 / USB-TTL-64

Hinweis:

Mit der Standard Ausführung des USB Treibers können mehrere USB Produkte mit unterschiedlichen Modul-IDs (z.B. ein RO-USB und ein USB-OPTOIN-8) angesprochen werden. Hierbei ist keine weitere Treiberinstallation erforderlich.

Wenn mehrere USB Produkte mit gleicher Modul-ID (z.B. ein USB-OPTOIN-8 und ein USB-RELAIS-8) angesprochen werden sollen, muss zusätzlich der Linux FTDI-Treiber installiert sein. Den FTDI-Treiber finden Sie unter http://www.ftdichip.com.

DELIB Ethernet Treiber

Unterstützung für folgende Produkte:

  • NET-Serie (über Ethernet Schnittstelle)
  • RO-ETH-Serie
  • RO-ETH/LC-Serie
  • BS-ETH-Serie
  • ETH-OPTION-8 / ETH-RELAIS-8
  • ETH-TTL-64

DELIB CLI

Mit dem DELIB CLI (Command Line Interface) für Linux können alle Befehle für digitale und analoge I/Os direkt über die Kommando-Zeile gesetzt werden

DELIB-Samples Installationspaket (ca. 10 MB)
Beispielprogramme für verschiedene Programmiersprachen (Im DELIB Setup enthalten)
Download
  • C (Microsoft Visual C++ 6.0, Borland C)
  • C++ (Microsoft Visual C++ 6.0)
  • C# (Microsoft Visual C# 2008 bis 2015)
  • Delphi (Borland Delphi 7)
  • VB (Microsoft Visual Basic 6.0)
  • VB.NET (Microsoft Visual Basic 2008 bis 2015)
  • Java (Java Native Interface)
  • Java.dll (Ethernet-Protokoll für Ethernet-Produkte)
Handbuch Protokolle & Registerbelegung
Übertragungsprotokolle und Registerbelegung
Download

Beschreibt den Aufbau unseres Ethernet-/Seriell- und CAN-Protokolls.
Beinhaltet auch eine Übersicht der Register für den Zugriff auf Ein-/Ausgänge und Zusatzfunktionen eines Produktes.

Download

Hardware-Updates (Firmware)
Flash Files für den DT-Flasher
Download

Die Flash Files können auch direkt im DT-Flasher heruntergeladen werden.

Dieses Paket enthält Firmware Dateien für die folgenden Produkte:

 

STARTER-Serie:

  • USB-MINI-Sticks
  • USB-8-er Opto/Relais
  • Ethernet 8-er Opto/Relais
  • USB-TTL I/O
  • Ethernet-TTL I/O

BS-Serie:

  • BS-CAN Module
  • BS-ETH Module
  • BS-USB Module
  • BS-SER Module

RO-Serie Interfaces:

  • RO-USB
  • RO-SER
  • RO-ETH
  • RO-ETH/LC
  • RO-CAN

RO-Serie I/Os:

  • AD / DA Module
  • CNT8 / CNT-IGR
  • O8-R8 Zeitmodul
  • PT100
  • Stepper2

Entwicklungszubehör

  • USB Controller 8
  • USB Watchdog Stick

DEDITEC Treiber CD

DEDITEC Treiber CD mit vielen hilfreichen Tools und Handbüchern zur Inbetriebnahme Ihrer DEDITEC Produkte.

  • DELIB Treiberbibliothek für Windows
  • Test- und Konfigurationssoftware
  • Handbücher
  • Datenblätter
  • Beispielprogramme für C++, C#, VB, VB.Net, Delphi, LabVIEW

Bewertungen

Es gibt noch keine Bewertungen.

Schreibe die erste Bewertung für „8*TTL-Ein-/Ausgänge über den USB Bus steuern und abfragen“

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.