英创信息技术嵌入式系统设备驱动接口的C#编程

英创ARM9系列嵌入式主板，均预装了WinCE 5.0、WinCE 6.0操作系统，用户可使用标准的C/C++或C#进行应用程序的开发。英创的嵌入式板卡一大特色就是提供了丰富的通讯接口，并实现了相应的驱动程序，用户只需直接调用相应的接口函数即可实现。

在使用C#进行应用程序开发时，由于C#无法使用C++的静态库函数，对于一些流式驱动设备，比如ISA，GPIO，WDT，CAN，SPI，IRQ等，没有封装好的库函数可操作，如果希望控制它们，一种办法是使用C编写com组件，在com组件中调用英创提供的相应主板SDK包里的静态库函数;另一种方法是直接调用API函数来访问设备驱动。

对于大多数的流式驱动设备，应用程序使用的一般过程：
        1、通过CreatFile打开设备，获得设备句柄。
        2、使用ReadFile读取数据，使用WriteFile发送数据，以及使用DeviceIoControl对设备驱动进行设置、读写等操作。
        3、使用完毕，用CloseHandle关闭设备。

在一般情况下，设备的专用功能都是通过DeviceIoControl来实现的，因此如何通过C#编程来操作DeviceIoControl尤为重要。本文以英创ARM9嵌入式主板EM9170为例，介绍如何使用DeviceIoControl来操作主板的ISA接口进行读写。GPIO，WDT，CAN，SPI，IRQ等其他流式设备的操作请参看英创开发光盘内提供的相关例程。

1、DeviceIoControl函数的定义
        在wince中核心库为coredll.dll，相当于window的kernel32.dll和user32.dll。要调用核心库，首先需要在代码中添加引用：

using System.Runtime.InteropServices;

在c#中DeviceIoControl及CreatFiles，CloseHandle函数声明，及相关变量定义方法如下（该写法并不固定）。

[DllImport('coredll.dll', EntryPoint = 'CreateFile', CharSet = CharSet.Unicode)] 
private static extern int CreateFile(String lpFileName, 
        uint dwDesiredAccess, 
        uint dwShareMode, 
        int lpSecurityAttributes, 
        int dwCreationDisposition, 
        int dwFlagsAndAttributes, 
        int hTemplateFile);

[DllImport('coredll.dll', EntryPoint = 'CloseHandle')] 
private static extern int CloseHandle(int hObject);

[DllImport('coredll.dll', EntryPoint = 'DeviceIoControl')]
private static extern bool DeviceIoControl(int hDevice,
        uint dwIoControlCode,
        byte[] lpInBuf,
        uint nInBufSize,
        byte[] lpOutBuf,
        uint nOutBufSize,
        ref uint lpBytesReturned,
        uint lpOverlapped);

DeviceIoControl函数参数分析：

在C#调用外部dll时，可以用uint来对应DWORD，用ref uint来对应LPDWORD，用IntPtr来对应各种指针，更通用的，可以直接使用byte[]来对应各种指针。

2、DeviceIoControl函数的操作实例
        以英创嵌入式主板EM9170的ISA操作为例，以下代码包括了CreatFile需要的参数定义，ISA操作的IOCTL定义，和ISA的DeviceIoControl操作传入参数结构体的定义，和封装DeviceIoControl的两个ISA函数定义。

主函数操作程序打开ISA设备，并操作ISA输出输入，最后关闭设备。

private const uint GENERIC_READ = 0x80000000;
private const uint GENERIC_WRITE = 0x40000000;
private const uint FILE_SHARE_READ = 0x00000001;
private const uint FILE_SHARE_WRITE = 0x00000002;
private const int OPEN_EXISTING = 3;
private const int FILE_FLAG_RANDOM_ACCESS = 0x10000000;
//------------------------bsp_drivers----------------------------------
//winioctl
private const uint FILE_DEVICE_BUS_EXTENDER = 0x0000002a;
private const uint METHOD_BUFFERED = 0;
private const uint FILE_ANY_ACCESS = 0;
// ISA IO Control Codes
private const uint ISA_IOCTL_READ_WRITE = (FILE_DEVICE_BUS_EXTENDER << 16) | (FILE_ANY_ACCESS << 14) | (3910 << 2) | (METHOD_BUFFERED);
private const uint ISA_IOCTL_BUS_RESET = (FILE_DEVICE_BUS_EXTENDER << 16) | (FILE_ANY_ACCESS << 14) | (3911 << 2) | (METHOD_BUFFERED);
//------------------------bsp_drivers_end------------------------------
[StructLayout(LayoutKind.Explicit, Size = 16)]
public struct ISA_BUS_ACCESS
{
        [FieldOffset(0)]public uint dwCmd; // = 0: Read, = 1: Write
        [FieldOffset(4)]public uint dwSeg; // = 0: ISA_CS0, = 1: ISA_CS1
        [FieldOffset(8)]public uint dwOffset;
        [FieldOffset(12)]public uint dwValue; // only lower byte valid
}
public static int OpenISA_DIO(String DevName)
{
        int handle; 
        handle = CreateFile(DevName,
        GENERIC_READ | GENERIC_WRITE, 
        FILE_SHARE_READ | FILE_SHARE_WRITE, // sharing mode
        0, // security attributes (ignored)
        OPEN_EXISTING, // creation disposition
        FILE_FLAG_RANDOM_ACCESS, // flags/attributes
        0);
        return handle;
}
public static bool CloseISA_DIO(int hISA_DIO)
{
        if (hISA_DIO != 0)
        {
                if (CloseHandle(hISA_DIO) != 0)
                {
                        return false;
                }
        }
        return true;
}
public static bool ISA_Read(int hISA_DIO, int nSeg, uint nOffset, ref byte pRdValue)
{
        ISA_BUS_ACCESS isabus;
        uint lpBytesReturned = 0;
        isabus.dwCmd = 0;
        isabus.dwSeg = (uint)nSeg;
        isabus.dwOffset = nOffset;
        isabus.dwValue = 0;
        int size = Marshal.SizeOf(typeof(ISA_BUS_ACCESS));
        byte[] lpIntBuf = new byte[size];
        IntPtr buffer = Marshal.AllocHGlobal(size);
        try
        {
                Marshal.StructureToPtr(isabus, buffer, false);
                Marshal.Copy(buffer, lpIntBuf, 0, size);
        }
        finally
        {
                Marshal.FreeHGlobal(buffer);
        }
        byte[] lpOutBuf = new byte[sizeof(byte)];
        if (!DeviceIoControl(hISA_DIO, // file handle to the driver
                ISA_IOCTL_READ_WRITE, // I/O control code
                lpIntBuf, // in buffer
                (uint)size, // in buffer size
                lpOutBuf, // out buffer
                sizeof(byte), // out buffer size
                ref lpBytesReturned, // pointer to number of bytes returned
                0)) // ignored (=NULL)
        {
                return false;
        }
        pRdValue = lpOutBuf[0];
        return true;
}
public static bool ISA_Write(int hISA_DIO, int nSeg, uint nOffset, byte ucWrValue)
{
        ISA_BUS_ACCESS isabus;
        uint lpBytesReturned = 0;
        isabus.dwCmd = 1;
        isabus.dwSeg = (uint)nSeg;
        isabus.dwOffset = nOffset;
        isabus.dwValue = (uint)ucWrValue;
        int size = Marshal.SizeOf(typeof(ISA_BUS_ACCESS));
        byte[] lpIntBuf = new byte[size];
        IntPtr buffer = Marshal.AllocHGlobal(size);
        try
        {
                Marshal.StructureToPtr(isabus, buffer, false);
                Marshal.Copy(buffer, lpIntBuf, 0, size);
        }
        finally
        {
                Marshal.FreeHGlobal(buffer);
        }
        if (!DeviceIoControl(hISA_DIO, // file handle to the driver
                ISA_IOCTL_READ_WRITE, // I/O control code
                lpIntBuf, // in buffer
                (uint)size, // in buffer size 
                null, // out buffer
                0, // out buffer size
                ref lpBytesReturned, // pointer to number of bytes returned
                0)) // ignored (=NULL)
        {
                return false;
        }
        return true;
}
static void Main(string[] args)
{
        const int ISA_CS1 = 1;
        int hISA;
        hISA = OpenISA_DIO('ISA1:');
        if( hISA == -1 )
        {
                Console.Write('Open ISA_DIO device fail!');
                return;
        }
        bRet = ISA_Write(hISA, ISA_CS1, 0, b);
        bRet = ISA_Read(hISA, ISA_CS1, 0, ref b);
        CloseISA_DIO(hISA);
        return;
}

3、传递结构体的操作说明
        该例程的ISA_Read，ISA_Write和函数中，DeviceIoControl的参数lpIntBuf需要传递一个结构体指针，关于结构体的操作需要按以下步骤。

所以首先需要定义一个和接口定义相同的结构体，在C#中定义与C接口的结构体需要使用StructLayout字段声明结构体的大小，和对齐规则。

在每个成员前面用FieldOffset字段设定该成员在结构体中的偏移。

[StructLayout(LayoutKind.Explicit, Size = 16)]
public struct ISA_BUS_ACCESS
{
        [FieldOffset(0)]public uint dwCmd; // = 0: Read, = 1: Write
        [FieldOffset(4)]public uint dwSeg; // = 0: ISA_CS0, = 1: ISA_CS1
        [FieldOffset(8)]public uint dwOffset;
        [FieldOffset(12)]public uint dwValue; // only lower byte valid
}

然后设定结构体各成员值，将结构体拷贝到byte[]中，在C#中将结构体拷贝到byte数组需要使用Marshal类。

首先计算结构体大小
        int size = Marshal.SizeOf(typeof(ISA_BUS_ACCESS));

创建一个byte[]
        byte[] lpIntBuf = new byte[size];

用AllocHGlobal申请一块非托管空间，并获得该空间的指针
        IntPtr buffer = Marshal.AllocHGlobal(size);

然后用StructureToPtr将结构体拷贝到指针位置，再用Copy将指针位置数据拷贝到byte数组。因为之前申请了内存空间，使用try-finally确报用FreeHGlobal释放空间

try
{
        Marshal.StructureToPtr(isabus, buffer, false);
        Marshal.Copy(buffer, lpIntBuf, 0, size);
}
finally
{
        Marshal.FreeHGlobal(buffer);
}

以上操作包括空间申请与释放，效率并不高，为提高效率，应当将结构体成员变量值直接赋值到byte数组相应位置，如： 
        ISA_BUS_ACCESS isabus;
        isabus.dwCmd = 1;

修改为
        lpIntBuf[3] = 1; 

注意整数的低位在高地址。

4、英创EM9170其他使用DeviceIoControl操作的设备dwIoControlCode值定义

//------------------------bsp_drivers----------------------------------
//winioctl
private const uint FILE_DEVICE_BUS_EXTENDER = 0x0000002a;
private const uint METHOD_BUFFERED = 0;
private const uint FILE_ANY_ACCESS = 0;
// GPIO IO Control Codes
private const uint GPIO_IOCTL_OUT_ENABLE = (FILE_DEVICE_BUS_EXTENDER << 16) | (FILE_ANY_ACCESS << 14) | ( 3900<< 2) | (METHOD_BUFFERED);
private const uint GPIO_IOCTL_OUT_DISABLE = (FILE_DEVICE_BUS_EXTENDER << 16) | (FILE_ANY_ACCESS << 14) | (3901 << 2) | (METHOD_BUFFERED);
private const uint GPIO_IOCTL_OUT_SET = (FILE_DEVICE_BUS_EXTENDER << 16) | (FILE_ANY_ACCESS << 14) | (3902 << 2) | (METHOD_BUFFERED);
private const uint GPIO_IOCTL_OUT_CLEAR = (FILE_DEVICE_BUS_EXTENDER << 16) | (FILE_ANY_ACCESS << 14) | (3903 << 2) | (METHOD_BUFFERED);
private const uint GPIO_IOCTL_PIN_STATE = (FILE_DEVICE_BUS_EXTENDER << 16) | (FILE_ANY_ACCESS << 14) | (3904 << 2) | (METHOD_BUFFERED);
// ISA IO Control Codes
private const uint ISA_IOCTL_READ_WRITE = (FILE_DEVICE_BUS_EXTENDER << 16) | (FILE_ANY_ACCESS << 14) | (3910 << 2) | (METHOD_BUFFERED);
private const uint ISA_IOCTL_BUS_RESET = (FILE_DEVICE_BUS_EXTENDER << 16) | (FILE_ANY_ACCESS << 14) | (3911 << 2) | (METHOD_BUFFERED);
//private const uint ISA_IOCTL_REDA_CS1 = (FILE_DEVICE_BUS_EXTENDER << 16) | (FILE_ANY_ACCESS << 14) | (3912 << 2) | (METHOD_BUFFERED);
//private const uint ISA_IOCTL_WRITE_CS1 = (FILE_DEVICE_BUS_EXTENDER << 16) | (FILE_ANY_ACCESS << 14) | (3913 << 2) | (METHOD_BUFFERED);
// SPI IO Control Codes
private const uint CSPI_IOCTL_EXCHANGE = (FILE_DEVICE_BUS_EXTENDER << 16) | (FILE_ANY_ACCESS << 14) | (3030 << 2) | (METHOD_BUFFERED);
// IRQ IO Control Codes
private const uint IOCTL_WAIT_FOR_IRQ = (FILE_DEVICE_BUS_EXTENDER << 16) | (FILE_ANY_ACCESS << 14) | (3920 << 2) | (METHOD_BUFFERED);
private const uint IOCTL_SEND_EOI = (FILE_DEVICE_BUS_EXTENDER << 16) | (FILE_ANY_ACCESS << 14) | (3921 << 2) | (METHOD_BUFFERED);
//------------------------bsp_drivers_end------------------------------