www.LaserFreak.net

Code: Alles auswählen

#include <stdio.h>
#include <windows.h>

// types for library functions
typedef unsigned char TDMXArray[512];
typedef char TSERIAL[16];
typedef TSERIAL TSERIALLIST[32];
typedef void (STDCALL* THOSTDEVICECHANGEPROC) (void);

// define library functions
typedef void (STDCALL* TGetAllConnectedInterfaces) (TSERIALLIST* SerialList);
TGetAllConnectedInterfaces GetAllConnectedInterfaces;
typedef void (STDCALL* TGetAllOpenedInterfaces) (TSERIALLIST* SerialList);
TGetAllOpenedInterfaces GetAllOpenedInterfaces;
typedef DWORD (STDCALL* TSetInterfaceMode) (TSERIAL Serial, unsigned char Mode);
TSetInterfaceMode SetInterfaceMode;
typedef DWORD (STDCALL* TOpenLink) (TSERIAL Serial, TDMXArray *DMXOutArray, TDMXArray *DMXInArray);
TOpenLink OpenLink;
typedef DWORD (STDCALL* TCloseLink) (TSERIAL Serial);
TCloseLink CloseLink;
typedef DWORD (STDCALL* TCloseAllLinks) (void);
TCloseAllLinks CloseAllLinks;
typedef DWORD (STDCALL* TRegisterInterfaceChangeNotification) (THOSTDEVICECHANGEPROC Proc);
TRegisterInterfaceChangeNotification RegisterInterfaceChangeNotification;
typedef DWORD (STDCALL* TUnregisterInterfaceChangeNotification) (void);
TUnregisterInterfaceChangeNotification UnregisterInterfaceChangeNotification;
typedef DWORD (STDCALL* TRegisterInputChangeNotification) (THOSTDEVICECHANGEPROC Proc);
TRegisterInputChangeNotification RegisterInputChangeNotification;
typedef DWORD (STDCALL* TUnregisterInputChangeNotification) (void);
TUnregisterInputChangeNotification UnregisterInputChangeNotification;

void InterfaceChange(void) {
  printf("Interface configuration has changed\n");
}

void InputChange(void) {
  printf("Input has changed\n");
}

int main(int argc, char *argv[])
{

  HINSTANCE dll_handle = LoadLibrary("usbdmx.dll");

  // Get library function addresses
  GetAllConnectedInterfaces = (TGetAllConnectedInterfaces)GetProcAddress(dll_handle, "GetAllConnectedInterfaces");
  GetAllOpenedInterfaces = (TGetAllOpenedInterfaces)GetProcAddress(dll_handle, "GetAllOpenedInterfaces");
  SetInterfaceMode = (TSetInterfaceMode)GetProcAddress(dll_handle, "SetInterfaceMode");
  OpenLink = (TOpenLink)GetProcAddress(dll_handle, "OpenLink");
  CloseLink = (TCloseLink)GetProcAddress(dll_handle, "CloseLink");
  CloseAllLinks = (TCloseAllLinks)GetProcAddress(dll_handle, "CloseAllLinks");
  RegisterInterfaceChangeNotification = (TRegisterInterfaceChangeNotification)GetProcAddress(dll_handle, "RegisterInterfaceChangeNotification");
  UnregisterInterfaceChangeNotification = (TUnregisterInterfaceChangeNotification)GetProcAddress(dll_handle, "UnregisterInterfaceChangeNotification");
  RegisterInputChangeNotification = (TRegisterInputChangeNotification)GetProcAddress(dll_handle, "RegisterInputChangeNotification");
  UnregisterInputChangeNotification = (TUnregisterInputChangeNotification)GetProcAddress(dll_handle, "UnregisterInputChangeNotification");

  // "InterfaceList" is filled by "GetAllConnectedInterfaces" or "GetAllOpenedInterfaces"
  // It contains the serials of up to 32 connected interfaces. A serial (16 characters) is
  // an array of char with a fixed length of 16, it is not a null terminated string (there is no null-termination)
  TSERIALLIST InterfaceList;

  // "DMX_Out" "DMX_In" are the DMX data buffers
  TDMXArray DMX_Out, DMX_In;

  // You can (optional) register a parameterless function which will be called when an interface is connected/disconnected
  RegisterInterfaceChangeNotification(&InterfaceChange);

  // You can (optional) register a parameterless function which will be called if at least one interface is configurated in input mode and some input channels have changed
  RegisterInputChangeNotification(&InputChange);

  // Here you get the list of all connected interfaces. If the value (serial) of "0000000000000000" occurs in the list then there are no more interfaces connected
  GetAllConnectedInterfaces(&InterfaceList);

  // With this function you open a link to the specified interface. Also you have to turn over the pointer to your DMX buffers.
  // The first pointer points to the DMX out buffer (PC -> Interface), the second to the DMX in buffer (Interface -> PC)
  // If you don't use either DMX output or DMX input you can set the corresponding pointer to zero.
  // (In this example simply the first interface of the list returned from "GetAllConnectedInterfaces" is opened without testing if there is connected any interface to the PC)
  OpenLink(InterfaceList[0], &DMX_Out, &DMX_In);

  // If you would call "GetAllOpenedInterfaces" here you'd get a list that contains only one valid serial: InterfaceList[0]

  // Now you can set the mode of the specified interface (a link must be opened).
  // The following modes are allowed:
  // 0: Do nothing - Standby
  // 1: DMX In -> DMX Out
  // 2: PC Out -> DMX Out
  // 3: DMX In + PC Out -> DMX Out
  // 4: DMX In -> PC In
  // 5: DMX In -> DMX Out & DMX In -> PC In
  // 6: PC Out -> DMX Out & DMX In -> PC In
  // 7: DMX In + PC Out -> DMX Out & DMX In -> PC In
  // If you want simply write to the DMX output use mode 2, if you want also read the DMX input use mode 6
  SetInterfaceMode(InterfaceList[0], 6);

  // Your main programm loop
  while (getc(stdin) != 'e') {

    // Now you can write to your DMX out buffer. The dll detects any change and the new values are transmitted to the interface
    DMX_Out[0] = 1;
    DMX_Out[1] = 2;
    DMX_Out[2] = 3;
    DMX_Out[3] = 4;
    //... and so on ...

    // Or you can read from the DMX input. If you have registered a function with "RegisterInputChangeNotification" it will be called everytime a channel changes it's value.
    // Every time the function is called up to 32 channels may have changed their value. Please hold the registered function as short as possible (< 1ms execution time)
    unsigned char tmp;
    tmp = DMX_In[0];
    tmp = DMX_In[1];
    tmp = DMX_In[2];
    tmp = DMX_In[3];
    //... and so on ...

    Sleep(10);
  }

  // At the end of the programm you should clean up a little
  CloseLink(InterfaceList[0]);
  UnregisterInputChangeNotification;
  UnregisterInterfaceChangeNotification;

  FreeLibrary(dll_handle);
  return 0;
}

Code: Alles auswählen

usbdmx.dll - Schnittstelle:
-----------
Funktionen:
-----------

GetAllConnectedInterfaces: TSERIALLIST;
GetAllOpenedInterfaces: TSERIALLIST;
SetInterfaceMode(Serial: TSERIAL; Mode: byte): DWORD;
OpenLink(Serial: TSERIAL; DMXOutArray: PDMXArray; DMXInArray: PDMXArray): DWORD;
CloseLink(Serial: TSERIAL): DWORD;
CloseAllLinks: DWORD;
RegisterInterfaceChangeNotification(Proc: THOSTDEVICECHANGEPROC): DWORD;
UnregisterInterfaceChangeNotification: DWORD;
RegisterInputChangeNotification(Proc: THOSTINPUTCHANGEPROC): DWORD;
UnregisterInputChangeNotification: DWORD;
GetDeviceVersion(Serial: TSERIAL): DWORD;
SetInterfaceAdvTxConfig(Serial: TSERIAL; Control: Byte; Breaktime: word; Marktime: word; Interbytetime: word; Interframetime: word; Channelcount: word; Startbyte: byte): DWORD; stdcall; // >= v1.1
StoreInterfaceAdvTxConfig(Serial: TSERIAL): DWORD; stdcall; // >= v1.1
RegisterInputChangeBlockNotification(Proc: THOSTINPUTCHANGEPROCBLOCK): DWORD; // >= v1.1
UnregisterInputChangeBlockNotification: DWORD; // >= v1.1


-------------------------------------
Object-Pascal Deklarationsvorschläge:
-------------------------------------

function GetAllConnectedInterfaces: TSERIALLIST; stdcall external 'usbdmx.dll';
function GetAllOpenedInterfaces: TSERIALLIST; stdcall external 'usbdmx.dll';
function SetInterfaceMode(Serial: TSERIAL; Mode: byte): DWORD; stdcall external 'usbdmx.dll';
function OpenLink(Serial: TSERIAL; DMXOutArray: PDMXArray; DMXInArray: PDMXArray): DWORD; stdcall external 'usbdmx.dll';
function CloseLink(Serial: TSERIAL): DWORD; stdcall external 'usbdmx.dll';
function CloseAllLinks: DWORD; stdcall external 'usbdmx.dll';
function RegisterInterfaceChangeNotification(Proc: THOSTDEVICECHANGEPROC): DWORD; stdcall external 'usbdmx.dll';
function UnregisterInterfaceChangeNotification: DWORD; stdcall external 'usbdmx.dll';
function RegisterInputChangeNotification(Proc: THOSTDEVICECHANGEPROC): DWORD; stdcall external 'usbdmx.dll';
function UnregisterInputChangeNotification: DWORD; stdcall external 'usbdmx.dll';
function GetDeviceVersion(Serial: TSERIAL): DWORD; stdcall external 'usbdmx.dll';
function SetInterfaceAdvTxConfig(Serial: TSERIAL; Control: Byte; Breaktime: word; Marktime: word; Interbytetime: word; Interframetime: word; Channelcount: word; Startbyte: byte): DWORD; stdcall; stdcall external 'usbdmx.dll';
function StoreInterfaceAdvTxConfig(Serial: TSERIAL): DWORD; stdcall; stdcall external 'usbdmx.dll';
function RegisterInputChangeBlockNotification(Proc: THOSTINPUTCHANGEPROCBLOCK): DWORD; stdcall external 'usbdmx.dll';
function UnregisterInputChangeBlockNotification: DWORD; stdcall external 'usbdmx.dll';


------
Werte:
------
Mode: 0 - Standby; 1 - DMX In -> DMX Out; 2 - PC Out -> DMX Out; 3 - DMX In + PC Out -> DMX Out; 4 - DMX In -> PC In; 5 - DMX In -> DMX Out & DMX In -> PC In; 6 - PC Out -> DMX Out & DMX In -> PC In; 7 - DMX In + PC Out -> DMX Out & DMX In -> PC In;
Version: 0x0100 = v1.00, 0x0110 = v1.10 usw.
ConfigControl: Bit 0: Enable Interbytedelay, Bit 1: Enable Interframedelay, Default = 0
Breaktime: Zeit des Resetpulses, 5,333us Schrittweite, Default = 17
Marktime: Zeit zwischen Resetpuls und Startbyte, 0.666us Schrittweite, Default = 13
Interbytetime: Zeit zwischen zwei Datenbytes (8N2), 0.666us Schrittweite, Default = 0
Interframetime: Zeit zwischen dem letzten Datenbyte und dem Resetpuls, 21,333us Schrittweite, Default = 0
Channelcount: Default = 512
Startbyte: Default = 0


------------------------------
Object-Pascal Typenvorschläge:
------------------------------

PDMXArray = ^TDMXArray;
TDMXArray = array[0..511] of byte;
TSERIAL = array[0..15] of Char;
TSERIALLIST = array[0..31] of TSERIAL;
THOSTDEVICECHANGEPROC = procedure; stdcall;
THOSTINPUTCHANGEPROC = procedure; stdcall;
THOSTINPUTCHANGEPROCBLOCK = procedure(blocknumber: byte); stdcall; // >= v1.1


------------------------
Hilfsroutinenvorschläge:
------------------------

function SerialToSerialstring(Serial: TSERIAL): string;
var i: byte;
begin
Result := '';
for i := 0 to 15 do Result := Result + Serial[i];
end;

function SerialstringToSerial(Serialstr: string): TSERIAL;
var i: byte;
    len: byte;
begin
len := length(Serialstr);
if len > 16 then len := 16;
for i := 0 to 15 do Result[i] := '0';
for i := 1 to len do Result[i + 15 - len] := Serialstr[i];
end;

Code: Alles auswählen

Declare Function GetAllInterfaces Lib "usbdmx.dll" (ByRef irgendwas As irgendwas)

Code: Alles auswählen

Private TSERIAL(15) As Char
Private TSERIALLIST(31) As TSERIAL ' <<< dies geht schonmal nicht weil ich keine Variable als Typ zuordnen kann

Private Declare Sub GetAllConnectedInterfaces Lib "usbdmx.dll" (ByRef Seriallist As TSERIALLIST)