• 1
oscargomezf

Adept library to use in visual .net c#

Question

Hi,

 

I would like to use the adept sdk library in visual .net with c#. Anyone knows how can I do that?

 

I've got this files from the Adept SDKv1-3:

 

dpcdefs.h
dpcutil.h
dpcutil.lib

 

But I don't know how to get a dpcutil.dll to use it in visual .net with c#.

 

Thank you. Best regards.

Share this post


Link to post
Share on other sites

2 answers to this question

Recommended Posts

  • 0

I solved the problem. This is the way to use the dpcutil.dll functions from Visual .Net c#:

 

const string _dllLocation = "C:WindowsSystem32dpcutil.dll";


[DllImport(_dllLocation, CallingConvention = CallingConvention.Cdecl)]
private static extern bool DpcInit(ref int perc);

Share this post


Link to post
Share on other sites
  • 0

I have an excellent example of interfacing with non-managed libraries using an internal sealed class. I have attached the file. I copied this foot print from another interface class regarding a USB interface. This example is nowhere near complete, but it provides the building block.

using System;
using System.IO;
using System.Runtime.InteropServices;

namespace Linear.common.lap.Digilent.Adept2
{
 /// <summary>
 /// This class library provides the 64-bit interface to the Digilent Inc. Adept2 dmgr library.
 /// </summary>
 internal sealed class StaticDmgr : IDisposable
 {
  // ReSharper disable InconsistentNaming
  /// <summary>
  /// The following value is passed to DmgrGetTransResult to specify
  /// wait until the transfer completes.
  /// </summary>
  public const UInt32 tmsWaitInfinite = 0xFFFFFFFF;

  // Handle to our DLL - used with GetProcAddress to load all of our functions
  private IntPtr hDMGR = IntPtr.Zero;

  // Declare pointers to each of the functions we are going to use in DMGR.DLL
  // These are assigned in our constructor and freed in our destructor.
  private readonly IntPtr pDmgrGetVersion = IntPtr.Zero;
  private readonly IntPtr pDmgrEnumDevices = IntPtr.Zero;
  private readonly IntPtr pDmgrGetDvc = IntPtr.Zero;
  private readonly IntPtr pDmgrIsEnumFinished = IntPtr.Zero;
  private readonly IntPtr pDmgrStopEnum = IntPtr.Zero;
  private readonly IntPtr pDmgrFreeDvcEnum = IntPtr.Zero;

  internal StaticDmgr()
  {
   // If DMGR.DLL is NOT loaded already, load it
   if (hDMGR == IntPtr.Zero)
   {
    // Load our DEPP.DLL library
    hDMGR = LoadLibrary(@"DMGR.DLL");
    if (hDMGR == IntPtr.Zero)
    {
     // Failed to load our DEPP.DLL library from System32 or the application directory
     // Try the same directory that this Adept2 DLL is in
     hDMGR = LoadLibrary(@Path.GetDirectoryName(GetType().Assembly.Location) + "\\DMGR.DLL");
    }
   }

   if (hDMGR == IntPtr.Zero)
    throw new ApplicationException("Cannot locate the driver's DMGR.DLL interface library.");

   // If we have succesfully loaded the library, get the function pointers set up
   // Set up our function pointers for use through our exported methods
   pDmgrGetVersion = GetProcAddress(hDMGR, "DmgrGetVersion");
   pDmgrEnumDevices = GetProcAddress(hDMGR, "DmgrEnumDevices");
   pDmgrGetDvc = GetProcAddress(hDMGR, "DmgrGetDvc");
   pDmgrIsEnumFinished = GetProcAddress(hDMGR, "DmgrIsEnumFinished");
   pDmgrStopEnum = GetProcAddress(hDMGR, "DmgrStopEnum");
   pDmgrFreeDvcEnum = GetProcAddress(hDMGR, "DmgrFreeDvcEnum");

   InitializeDelegates();
  }

  private void InitializeDelegates()
  {
   if (pDmgrGetVersion == IntPtr.Zero)
    throw new ApplicationException("Failed to load function DmgrGetVersion.");
   if (pDmgrEnumDevices == IntPtr.Zero)
    throw new ApplicationException("Failed to load function DmgrEnumDevices.");
   if (pDmgrIsEnumFinished == IntPtr.Zero)
    throw new ApplicationException("Failed to load function DmgrIsEnumFinished.");
   if (pDmgrStopEnum == IntPtr.Zero)
    throw new ApplicationException("Failed to load function DmgrStopEnum.");
   if (pDmgrFreeDvcEnum == IntPtr.Zero)
    throw new ApplicationException("Failed to load function DmgrFreeDvcEnum.");

   DmgrGetVersion = (tDmgrGetVersion)Marshal.GetDelegateForFunctionPointer(pDmgrGetVersion, typeof(tDmgrGetVersion));
   DmgrEnumDevices = (tDmgrEnumDevices)Marshal.GetDelegateForFunctionPointer(pDmgrEnumDevices, typeof(tDmgrEnumDevices));
   DmgrGetDvc = (tDmgrGetDvc)Marshal.GetDelegateForFunctionPointer(pDmgrGetDvc, typeof(tDmgrGetDvc));
   DmgrIsEnumFinished = (tDmgrIsEnumFinished)Marshal.GetDelegateForFunctionPointer(pDmgrIsEnumFinished, typeof(tDmgrIsEnumFinished));
   DmgrStopEnum = (tDmgrStopEnum)Marshal.GetDelegateForFunctionPointer(pDmgrStopEnum, typeof(tDmgrStopEnum));
   DmgrFreeDvcEnum = (tDmgrFreeDvcEnum)Marshal.GetDelegateForFunctionPointer(pDmgrFreeDvcEnum, typeof(tDmgrFreeDvcEnum));
  }

  #region Instantiated Function Delegates

  internal tDmgrGetVersion DmgrGetVersion;
  internal tDmgrEnumDevices DmgrEnumDevices;
  internal tDmgrGetDvc DmgrGetDvc;
  internal tDmgrIsEnumFinished DmgrIsEnumFinished;
  internal tDmgrStopEnum DmgrStopEnum;
  internal tDmgrFreeDvcEnum DmgrFreeDvcEnum;

  #endregion

  #region IDisposable Methods

  /// <summary>
  /// Destructor for the D2XX class.
  /// </summary>
  ~StaticDmgr()
  {
   if (hDMGR != IntPtr.Zero)
   {
    // FreeLibrary here - we should only do this if we are completely finished
    FreeLibrary(hDMGR);
    hDMGR = IntPtr.Zero;
   }
  }

  public void Dispose()
  {
   if (hDMGR != IntPtr.Zero)
   {
    // FreeLibrary here - we should only do this if we are completely finished
    FreeLibrary(hDMGR);
    hDMGR = IntPtr.Zero;
   }
  }

  #endregion

  #region Marshalling Methods to Unmanaged DMGR

  /// <summary>
  /// Built-in Windows API functions to allow us to dynamically load our own DLL.
  /// Will allow us to use old versions of the DLL that do not have all of these functions available.
  /// </summary>
  [DllImport("kernel32.dll")]
  private static extern IntPtr LoadLibrary(string dllToLoad);

  [DllImport("kernel32.dll")]
  private static extern IntPtr GetProcAddress(IntPtr hModule, string procedureName);

  [DllImport("kernel32.dll")]
  private static extern bool FreeLibrary(IntPtr hModule);

  // Definitions for DMGR functions
  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  internal delegate int tDmgrGetVersion(byte[] szVersion);
  //OPEN & CLOSE functions
  internal delegate int tDmgrOpen(ref int phif, byte[] szSel);
  internal delegate int tDmgrOpenEx(ref int phif, byte[] szSel, int dtpTable, int dtpDisc);
  internal delegate int tDmgrClose(int hif);
  //ENUMERATION functions
  internal delegate int tDmgrEnumDevices(ref int pcdvc);
  //internal delegate int tDmgrEnumDevicesEx(ref int pcdvc, int dtpTable, int dtpDisc, int dinfoSel);
  //internal delegate int tDmgrStartEnum(ref int pcdvc);
  internal delegate int tDmgrIsEnumFinished();
  internal delegate int tDmgrStopEnum();
  //internal delegate int tDmgrGetEnumCount(ref int pcdvc);
  internal delegate int tDmgrGetDvc(int pcdvc, byte [] dvc);
  internal delegate int tDmgrFreeDvcEnum();

  #endregion

 }
}

 

 

Edited by lukeswr
Removed confidential information.

Share this post


Link to post
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now