Quoting from the docs:

Sometimes you have instances of incompatible types. In C, you can cast one type into another type. ctypes provides a cast() function which can be used in the same way.

So, the Python equivalent of the C++ code is:

license = cast(d.GetLicense(), ctypes.POINTER(AppLicense))
license.GetApplicationStatus()

However, often this isn't necessary; you may be able to just do this:

d.GetLicense.restype = ctypes.POINTER(AppLicense)

This looks like "cheating", but it really isn't. You're just telling it to call the POINTER(AppLicense) constructor with the result. And since POINTER(AppLicense) is a ctypes data type, it will not have to first assume the result is a C int.

According to your error output:

  File "C:/Users/Steve/Documents/Python Scripts/otoDLL.py", line 5, in <module>
    spectrometerOpen.argtypes = (ctypes.c_uint, ctypes.POINTER(c_void_p),

You forget to put ctypes before c_void_p, thus:

spectrometerOpen.argtypes = (ctypes.c_uint, ctypes.POINTER(ctypes.c_void_p),
                         ctypes.c_uint, ctypes.c_uint)

According to your function signature , the handle parameter is a pointer to a void*, thus you need to pass it like this:

import ctypes
otoDLL = ctypes.CDLL('UserApplication.dll')
spectrometerOpen = otoDLL.UAI_SpectrometerOpen
spectrometerOpen.argtypes = (ctypes.c_uint, ctypes.POINTER(ctypes.c_void_p),
                         ctypes.c_uint, ctypes.c_uint)
spectrometerOpen.restypes = ctypes.c_uint

# declare HANDLE type, which is a void*
HANDLE = ctypes.c_void_p

# example: declare an instance of HANDLE, set to NULL (0)
my_handle = HANDLE(0)

#pass the handle by reference (works like passing a void**)
errorCode = spectrometerOpen(0, ctypes.byref(my_handle), 1592, 2732)

Note: this is just an example, you should check the documentation of the spectrometerOpen function to see what exactly it is awaiting exactly for the handle parameter (can it be NULL, what type is it exactly, etc.).

So the solution/answer is:

gVimbaHandle = c_void_p(1)
err = self.dll.VmbFeatureBoolGet(gVimbaHandle, "GeVTLIsPresent", byref(isGigE))

thanks @eryksun

You need to declare the argument types of the functions you call using argtypes. Since I don't know your exact API, here's an example:

Windows C DLL code with a callback:

typedef void (*CB)(int a);

__declspec(dllexport) void do_callback(CB func)
{
    int i;
    for(i=0;i<10;++i)
        func(i);
}

Python code:

from ctypes import *

# You can use as a Python decorator.
@CFUNCTYPE(None,c_int)
def callback(a):
  print(a)

# Use CDLL for __cdecl calling convention...WinDLL for __stdcall.
do_callback = CDLL('test').do_callback
do_callback.restype = None
do_callback.argtypes = [CFUNCTYPE(None,c_int)]

do_callback(callback)

Output:

0
1
2
3
4
5
6
7
8
9

Assuming txBuff is a list of integers, then you'll need to pack them into an array. The following code ought to work, but I can't test it...

def DPxWriteRam(address, int_list):
    int_size = ctypes.sizeof(ctypes.c_int)
    item_count = len(int_list)
    total_size = int_size * item_count
    packed_data = (ctypes.c_int * item_count)(*int_list)
    WriteRam(ctypes.c_uint(address), ctypes.c_uint(total_size), packed_data)

DPxWriteRam(whatever, [0, 1, 2, 3])

...although if WriteRam is pretty much just doing a memcpy(), then you could just use this...

import ctypes
libc = ctypes.CDLL('msvcrt.dll')

def DPxWriteRam(address, int_list):
    int_size = ctypes.sizeof(ctypes.c_int)
    item_count = len(int_list)
    total_size = int_size * item_count
    packed_data = (ctypes.c_int * item_count)(*int_list)
    libc.memcpy(address, packed_data, total_size)

...which I can test...

>>> l = range(4)
>>> p = libc.malloc(1000)
>>> DPxWriteRam(p, l)
>>> s = ' ' * 16
>>> libc.memcpy(s, p, 16)
>>> print repr(s)
'\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00'

For some reason, whoever designed ctypes decided it would be a good idea to transparently convert c_void_p values to Python ints when you retrieve struct members or array elements, or receive c_void_p values from foreign function calls. You can reverse the transformation by constructing a c_void_p again:

pointer_as_c_void_p = c_void_p(t.p)

If you want to convert to pointer-to-int, use cast:

pointer_as_int_pointer = cast(t.p, POINTER(c_int))

You can then index the pointer to retrieve values, or slice it to get a list:

print(pointer_as_int_pointer[1]) # prints 2
print(pointer_as_int_pointer[:3]) # prints [1, 2, 3]