AT91SAM9263 WINCE 6.0 R2驱动开发-GPIO流驱动的实现以及应用程序的调用

harkspan harkspan 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 1.6k累计阅读 1.7k平均单平台 已同步平台 CSDN 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄18年
关注
转载 最新推荐文章于 2026-06-19 13:40:29 发布 1.6k 阅读 AI 写同款· GEO 优化 ›
学习提速专享！AI工具全家桶免费用 限时购周边加赠Coding Plan Lite，解锁20+主流AI工具，写代码、查资料快人一步！ 阅读详情

1.实现GPIO的流驱动，源代码如下

view plaincopy to clipboardprint?
#include <windows.h>  
#include <types.h>  
#include <ceddk.h>  
#include <memory.h>  
#include <nkintr.h>  
#include <pegdpar.h>  
#include <ddkreg.h>  
#include <Winuser.h>  
#include "AT91SAM9263_oal_intr.h"  
#include "atmel_spi_ioctl.h"  
#include "AT91SAM9263EK_ioctl.h"  
#include    "at91sam9263_gpio.h"  
 
#define GIO_WRITE0  CTL_CODE(FILE_DEVICE_SERIAL_PORT, 2059, METHOD_BUFFERED, FILE_ANY_ACCESS)     
#define GIO_WRITE1  CTL_CODE(FILE_DEVICE_SERIAL_PORT, 2060, METHOD_BUFFERED, FILE_ANY_ACCESS)  
#define GIO_READ    CTL_CODE(FILE_DEVICE_SERIAL_PORT, 2061, METHOD_BUFFERED, FILE_ANY_ACCESS)     
 
// 0  
const struct pio_desc hw_pic20out[] =   
{  
    {"OUT", AT91C_PIN_PC(20), 0, PIO_PULLUP, PIO_OUTPUT},  
};  
const struct pio_desc hw_pic20in[] =   
{  
    {"OUT", AT91C_PIN_PC(20), 0, PIO_PULLUP, PIO_INPUT},  
};  
 
 
// 1  
const struct pio_desc hw_pic21out[] =   
{  
    {"OUT", AT91C_PIN_PC(21), 0, PIO_PULLUP, PIO_OUTPUT},  
};  
const struct pio_desc hw_pic21in[] =   
{  
    {"OUT", AT91C_PIN_PC(21), 0, PIO_PULLUP, PIO_INPUT},  
};  
 
// 2  
const struct pio_desc hw_pic22out[] =   
{  
    {"OUT", AT91C_PIN_PC(22), 0, PIO_PULLUP, PIO_OUTPUT},  
};  
const struct pio_desc hw_pic22in[] =   
{  
    {"OUT", AT91C_PIN_PC(22), 0, PIO_PULLUP, PIO_INPUT},  
};  
 
// 3  
const struct pio_desc hw_pic23out[] =   
{  
    {"OUT", AT91C_PIN_PC(23), 0, PIO_PULLUP, PIO_OUTPUT},  
};  
const struct pio_desc hw_pic23in[] =   
{  
    {"OUT", AT91C_PIN_PC(23), 0, PIO_PULLUP, PIO_INPUT},  
};  
 
// 4  
const struct pio_desc hw_pic24out[] =   
{  
    {"OUT", AT91C_PIN_PC(24), 0, PIO_PULLUP, PIO_OUTPUT},  
};  
const struct pio_desc hw_pic24in[] =   
{  
    {"OUT", AT91C_PIN_PC(24), 0, PIO_PULLUP, PIO_INPUT},  
};  
 
// 5  
const struct pio_desc hw_pie18out[] =   
{  
    {"OUT", AT91C_PIN_PE(18), 0, PIO_PULLUP, PIO_OUTPUT},  
};  
const struct pio_desc hw_pie18in[] =   
{  
    {"OUT", AT91C_PIN_PE(18), 0, PIO_PULLUP, PIO_INPUT},  
};  
 
BOOL APIENTRY DllMain( HANDLE hModule,DWORD ul_reason_for_call,LPVOID lpReserved )  
{  
  switch (ul_reason_for_call)  
    {  
        case DLL_PROCESS_ATTACH:  
            //RETAILMSG(0,(TEXT("GIO Process Attach/r/n")));  
            break;  
        case DLL_THREAD_ATTACH:  
            //RETAILMSG(0,(TEXT("GIO Thread  Attach/r/n")));  
            break;  
        case DLL_THREAD_DETACH:  
            //RETAILMSG(0,(TEXT("GIO Thread  Detach/r/n")));  
            break;  
        case DLL_PROCESS_DETACH:  
            //RETAILMSG(0,(TEXT("GIO Process Detach/r/n")));  
            break;  
    }  
    return TRUE;  
}  
 
DWORD GIO_Init(LPCTSTR pContext,LPCVOID lpBusContext)   
{     
    RETAILMSG(1,(TEXT("+GIO_Init/r/n")));  
    RETAILMSG(1,(TEXT("-GIO_Init/r/n")));  
     return(TRUE);  
}  
 
 
BOOL  GIO_Deinit(LPCTSTR hDeviceContext)  
{  
    return TRUE;      
}  
 
 DWORD GIO_Open(LPCTSTR hDeviceContext,DWORD AccessCode,DWORD ShareMode)  
{  
    return (DWORD)hDeviceContext;  
}  
 
 DWORD GIO_Close(LPCTSTR pOpenContext)  
{  
    return TRUE;  
}  
 DWORD GIO_Write(LPCTSTR pOpenContext,LPCVOID pBuffer,DWORD Count)  
{  
    return -1;  
}  
 
DWORD GIO_Read(LPCTSTR pOpenContext,LPCVOID pBuffer,DWORD Count)  
{  
    return -1;  
}  
 
BOOL GIO_IOControl(DWORD  hOpenContext,  
                   DWORD  dwCode,  
                   PBYTE  pBufIn,  
                   DWORD  dwLenIn,  
                   PBYTE  pBufOut,  
                   DWORD  dwLenOut,  
                   PDWORD pdwActualOut)  
{  
    BOOL bError = FALSE;  
    RETAILMSG(1,(TEXT("+GIO_IOControl/r/n")));  
    switch(dwCode)  
    {  
        case GIO_READ:  
            switch(*pBufIn)  
                {  
                    case 0:  
                        pio_setup(hw_pic20in, sizeof(hw_pic20in)/sizeof(struct pio_desc));  
                        *(DWORD *)pBufOut=(DWORD)(pio_get_value(AT91C_PIN_PC(20)));  
                        break;  
                    case 1:  
                        pio_setup(hw_pic21in, sizeof(hw_pic21in)/sizeof(struct pio_desc));  
                        *(DWORD*)pBufOut=(DWORD)(pio_get_value(AT91C_PIN_PC(21)));  
                        break;  
                    case 2:  
                        pio_setup(hw_pic22in, sizeof(hw_pic22in)/sizeof(struct pio_desc));  
                        *(DWORD *)pBufOut=(DWORD)(pio_get_value(AT91C_PIN_PC(22)));  
                        break;  
                    case 3:  
                        pio_setup(hw_pic23in, sizeof(hw_pic23in)/sizeof(struct pio_desc));  
                        *(DWORD *)pBufOut=(DWORD)(pio_get_value(AT91C_PIN_PC(23)));  
                        break;  
                    case 4:  
                        pio_setup(hw_pic24in, sizeof(hw_pic24in)/sizeof(struct pio_desc));  
                        *(DWORD *)pBufOut=(DWORD)(pio_get_value(AT91C_PIN_PC(24)));  
                        break;  
                    case 5:  
                        pio_setup(hw_pie18in, sizeof(hw_pie18in)/sizeof(struct pio_desc));  
                        *(DWORD *)pBufOut=(DWORD)(pio_get_value(AT91C_PIN_PE(18)));  
                        break;  
                    default:  
                        break;  
                }  
            break;  
        case GIO_WRITE0:  
            switch(*pBufIn)  
                {  
                    case 0:  
                        pio_setup(hw_pic20out, sizeof(hw_pic20out)/sizeof(struct pio_desc));  
                        pio_set_value(AT91C_PIN_PC(20), 0);  
                        break;  
                    case 1:  
                        pio_setup(hw_pic21out, sizeof(hw_pic21out)/sizeof(struct pio_desc));  
                        pio_set_value(AT91C_PIN_PC(21), 0);  
                        break;  
                    case 2:  
                        pio_setup(hw_pic22out, sizeof(hw_pic22out)/sizeof(struct pio_desc));  
                        pio_set_value(AT91C_PIN_PC(22), 0);  
                        break;  
                    case 3:  
                        pio_setup(hw_pic23out, sizeof(hw_pic23out)/sizeof(struct pio_desc));  
                        pio_set_value(AT91C_PIN_PC(23), 0);  
                        break;  
                    case 4:  
                        pio_setup(hw_pic24out, sizeof(hw_pic24out)/sizeof(struct pio_desc));  
                        pio_set_value(AT91C_PIN_PC(24), 0);  
                        break;  
                    case 5:  
                        pio_setup(hw_pie18out, sizeof(hw_pie18out)/sizeof(struct pio_desc));  
                        pio_set_value(AT91C_PIN_PE(18), 0);  
                        break;  
                }  
            break;  
        case GIO_WRITE1:  
            switch(*pBufIn)  
                {  
                    case 0:  
                        pio_setup(hw_pic20out, sizeof(hw_pic20out)/sizeof(struct pio_desc));  
                        pio_set_value(AT91C_PIN_PC(20), 1);  
                        break;  
                    case 1:  
                        pio_setup(hw_pic21out, sizeof(hw_pic21out)/sizeof(struct pio_desc));  
                        pio_set_value(AT91C_PIN_PC(21), 1);  
                        break;  
                    case 2:  
                        pio_setup(hw_pic22out, sizeof(hw_pic22out)/sizeof(struct pio_desc));  
                        pio_set_value(AT91C_PIN_PC(22), 1);  
                        break;  
                    case 3:  
                        pio_setup(hw_pic23out, sizeof(hw_pic23out)/sizeof(struct pio_desc));  
                        pio_set_value(AT91C_PIN_PC(23), 1);  
                        break;  
                    case 4:  
                        pio_setup(hw_pic24out, sizeof(hw_pic24out)/sizeof(struct pio_desc));  
                        pio_set_value(AT91C_PIN_PC(24), 1);  
                        break;  
                    case 5:  
                        pio_setup(hw_pie18out, sizeof(hw_pie18out)/sizeof(struct pio_desc));  
                        pio_set_value(AT91C_PIN_PE(18),1);  
                        break;  
                }  
            break;  
    }  
    RETAILMSG(1,(TEXT("-GIO_IOControl/r/n")));  
    return bError;  
}  
 
DWORD GIO_Seek(LPCTSTR pOpenContext,LPCVOID pBuffer,DWORD Count)  
{  
   return -1;  
} 
#include <windows.h>
#include <types.h>
#include <ceddk.h>
#include <memory.h>
#include <nkintr.h>
#include <pegdpar.h>
#include <ddkreg.h>
#include <Winuser.h>
#include "AT91SAM9263_oal_intr.h"
#include "atmel_spi_ioctl.h"
#include "AT91SAM9263EK_ioctl.h"
#include "at91sam9263_gpio.h"

#define GIO_WRITE0 CTL_CODE(FILE_DEVICE_SERIAL_PORT, 2059, METHOD_BUFFERED, FILE_ANY_ACCESS) 
#define GIO_WRITE1 CTL_CODE(FILE_DEVICE_SERIAL_PORT, 2060, METHOD_BUFFERED, FILE_ANY_ACCESS)
#define GIO_READ CTL_CODE(FILE_DEVICE_SERIAL_PORT, 2061, METHOD_BUFFERED, FILE_ANY_ACCESS) 

// 0
const struct pio_desc hw_pic20out[] =
{
 {"OUT", AT91C_PIN_PC(20), 0, PIO_PULLUP, PIO_OUTPUT},
};
const struct pio_desc hw_pic20in[] =
{
 {"OUT", AT91C_PIN_PC(20), 0, PIO_PULLUP, PIO_INPUT},
};


// 1
const struct pio_desc hw_pic21out[] =
{
 {"OUT", AT91C_PIN_PC(21), 0, PIO_PULLUP, PIO_OUTPUT},
};
const struct pio_desc hw_pic21in[] =
{
 {"OUT", AT91C_PIN_PC(21), 0, PIO_PULLUP, PIO_INPUT},
};

// 2
const struct pio_desc hw_pic22out[] =
{
 {"OUT", AT91C_PIN_PC(22), 0, PIO_PULLUP, PIO_OUTPUT},
};
const struct pio_desc hw_pic22in[] =
{
 {"OUT", AT91C_PIN_PC(22), 0, PIO_PULLUP, PIO_INPUT},
};

// 3
const struct pio_desc hw_pic23out[] =
{
 {"OUT", AT91C_PIN_PC(23), 0, PIO_PULLUP, PIO_OUTPUT},
};
const struct pio_desc hw_pic23in[] =
{
 {"OUT", AT91C_PIN_PC(23), 0, PIO_PULLUP, PIO_INPUT},
};

// 4
const struct pio_desc hw_pic24out[] =
{
 {"OUT", AT91C_PIN_PC(24), 0, PIO_PULLUP, PIO_OUTPUT},
};
const struct pio_desc hw_pic24in[] =
{
 {"OUT", AT91C_PIN_PC(24), 0, PIO_PULLUP, PIO_INPUT},
};

// 5
const struct pio_desc hw_pie18out[] =
{
 {"OUT", AT91C_PIN_PE(18), 0, PIO_PULLUP, PIO_OUTPUT},
};
const struct pio_desc hw_pie18in[] =
{
 {"OUT", AT91C_PIN_PE(18), 0, PIO_PULLUP, PIO_INPUT},
};

BOOL APIENTRY DllMain( HANDLE hModule,DWORD ul_reason_for_call,LPVOID lpReserved )
{
  switch (ul_reason_for_call)
 {
  case DLL_PROCESS_ATTACH:
   //RETAILMSG(0,(TEXT("GIO Process Attach/r/n")));
   break;
  case DLL_THREAD_ATTACH:
   //RETAILMSG(0,(TEXT("GIO Thread  Attach/r/n")));
   break;
  case DLL_THREAD_DETACH:
   //RETAILMSG(0,(TEXT("GIO Thread  Detach/r/n")));
   break;
  case DLL_PROCESS_DETACH:
   //RETAILMSG(0,(TEXT("GIO Process Detach/r/n")));
   break;
    }
    return TRUE;
}

DWORD GIO_Init(LPCTSTR pContext,LPCVOID lpBusContext)
{ 
 RETAILMSG(1,(TEXT("+GIO_Init/r/n")));
 RETAILMSG(1,(TEXT("-GIO_Init/r/n")));
  return(TRUE);
}


BOOL  GIO_Deinit(LPCTSTR hDeviceContext)
{
  return TRUE; 
}

 DWORD GIO_Open(LPCTSTR hDeviceContext,DWORD AccessCode,DWORD ShareMode)
{
 return (DWORD)hDeviceContext;
}

 DWORD GIO_Close(LPCTSTR pOpenContext)
{
 return TRUE;
}
 DWORD GIO_Write(LPCTSTR pOpenContext,LPCVOID pBuffer,DWORD Count)
{
 return -1;
}

DWORD GIO_Read(LPCTSTR pOpenContext,LPCVOID pBuffer,DWORD Count)
{
 return -1;
}

BOOL GIO_IOControl(DWORD  hOpenContext,
       DWORD  dwCode,
       PBYTE  pBufIn,
       DWORD  dwLenIn,
       PBYTE  pBufOut,
       DWORD  dwLenOut,
       PDWORD pdwActualOut)
{
 BOOL bError = FALSE;
 RETAILMSG(1,(TEXT("+GIO_IOControl/r/n")));
 switch(dwCode)
 {
  case GIO_READ:
   switch(*pBufIn)
    {
     case 0:
      pio_setup(hw_pic20in, sizeof(hw_pic20in)/sizeof(struct pio_desc));
      *(DWORD *)pBufOut=(DWORD)(pio_get_value(AT91C_PIN_PC(20)));
      break;
     case 1:
      pio_setup(hw_pic21in, sizeof(hw_pic21in)/sizeof(struct pio_desc));
      *(DWORD*)pBufOut=(DWORD)(pio_get_value(AT91C_PIN_PC(21)));
      break;
     case 2:
      pio_setup(hw_pic22in, sizeof(hw_pic22in)/sizeof(struct pio_desc));
      *(DWORD *)pBufOut=(DWORD)(pio_get_value(AT91C_PIN_PC(22)));
      break;
     case 3:
      pio_setup(hw_pic23in, sizeof(hw_pic23in)/sizeof(struct pio_desc));
      *(DWORD *)pBufOut=(DWORD)(pio_get_value(AT91C_PIN_PC(23)));
      break;
     case 4:
      pio_setup(hw_pic24in, sizeof(hw_pic24in)/sizeof(struct pio_desc));
      *(DWORD *)pBufOut=(DWORD)(pio_get_value(AT91C_PIN_PC(24)));
      break;
     case 5:
      pio_setup(hw_pie18in, sizeof(hw_pie18in)/sizeof(struct pio_desc));
      *(DWORD *)pBufOut=(DWORD)(pio_get_value(AT91C_PIN_PE(18)));
      break;
     default:
      break;
    }
   break;
  case GIO_WRITE0:
   switch(*pBufIn)
    {
     case 0:
      pio_setup(hw_pic20out, sizeof(hw_pic20out)/sizeof(struct pio_desc));
      pio_set_value(AT91C_PIN_PC(20), 0);
      break;
     case 1:
      pio_setup(hw_pic21out, sizeof(hw_pic21out)/sizeof(struct pio_desc));
      pio_set_value(AT91C_PIN_PC(21), 0);
      break;
     case 2:
      pio_setup(hw_pic22out, sizeof(hw_pic22out)/sizeof(struct pio_desc));
      pio_set_value(AT91C_PIN_PC(22), 0);
      break;
     case 3:
      pio_setup(hw_pic23out, sizeof(hw_pic23out)/sizeof(struct pio_desc));
      pio_set_value(AT91C_PIN_PC(23), 0);
      break;
     case 4:
      pio_setup(hw_pic24out, sizeof(hw_pic24out)/sizeof(struct pio_desc));
      pio_set_value(AT91C_PIN_PC(24), 0);
      break;
     case 5:
      pio_setup(hw_pie18out, sizeof(hw_pie18out)/sizeof(struct pio_desc));
      pio_set_value(AT91C_PIN_PE(18), 0);
      break;
    }
   break;
  case GIO_WRITE1:
   switch(*pBufIn)
    {
     case 0:
      pio_setup(hw_pic20out, sizeof(hw_pic20out)/sizeof(struct pio_desc));
      pio_set_value(AT91C_PIN_PC(20), 1);
      break;
     case 1:
      pio_setup(hw_pic21out, sizeof(hw_pic21out)/sizeof(struct pio_desc));
      pio_set_value(AT91C_PIN_PC(21), 1);
      break;
     case 2:
      pio_setup(hw_pic22out, sizeof(hw_pic22out)/sizeof(struct pio_desc));
      pio_set_value(AT91C_PIN_PC(22), 1);
      break;
     case 3:
      pio_setup(hw_pic23out, sizeof(hw_pic23out)/sizeof(struct pio_desc));
      pio_set_value(AT91C_PIN_PC(23), 1);
      break;
     case 4:
      pio_setup(hw_pic24out, sizeof(hw_pic24out)/sizeof(struct pio_desc));
      pio_set_value(AT91C_PIN_PC(24), 1);
      break;
     case 5:
      pio_setup(hw_pie18out, sizeof(hw_pie18out)/sizeof(struct pio_desc));
      pio_set_value(AT91C_PIN_PE(18),1);
      break;
    }
   break;
 }
 RETAILMSG(1,(TEXT("-GIO_IOControl/r/n")));
 return bError;
}

DWORD GIO_Seek(LPCTSTR pOpenContext,LPCVOID pBuffer,DWORD Count)
{
   return -1;
}

2.sources文件

view plaincopy to clipboardprint?
!if 0  
Copyright (c) 2005. Samsung Electronics, co. ltd.  All rights reserved.  
!endif  
!if 0  
Use of this source code is subject to the terms of the Microsoft end-user  
license agreement (EULA) under which you licensed this SOFTWARE PRODUCT.  
If you did not accept the terms of the EULA, you are not authorized to use  
this source code. For a copy of the EULA, please see the LICENSE.RTF on your  
install media.  
!endif  
 
RELEASETYPE=PLATFORM  
TARGETNAME=IO  
TARGETTYPE=DYNLINK  
DLLENTRY=DllMain  
 
SOURCES= /  
    IO.cpp   /  
 
TARGETLIBS= /  
    $(_COMMONSDKROOT)/lib/$(_CPUINDPATH)/coredll.lib /  
 
SOURCELIBS= /  
  $(_TARGETPLATROOT)/lib/$(_CPUDEPPATH)/gpio.lib /  
 
 
MSC_WARNING_LEVEL = $(MSC_WARNING_LEVEL) /W3 /WX  
 
INCLUDES= $(_TARGETPLATROOT)/SRC/inc;$(_COMMONOAKROOT)/inc;$(INCLUDES) 
!if 0
Copyright (c) 2005. Samsung Electronics, co. ltd.  All rights reserved.
!endif
!if 0
Use of this source code is subject to the terms of the Microsoft end-user
license agreement (EULA) under which you licensed this SOFTWARE PRODUCT.
If you did not accept the terms of the EULA, you are not authorized to use
this source code. For a copy of the EULA, please see the LICENSE.RTF on your
install media.
!endif

RELEASETYPE=PLATFORM
TARGETNAME=IO
TARGETTYPE=DYNLINK
DLLENTRY=DllMain

SOURCES= /
    IO.cpp   /

TARGETLIBS= /
    $(_COMMONSDKROOT)/lib/$(_CPUINDPATH)/coredll.lib /

SOURCELIBS= /
  $(_TARGETPLATROOT)/lib/$(_CPUDEPPATH)/gpio.lib /


MSC_WARNING_LEVEL = $(MSC_WARNING_LEVEL) /W3 /WX

INCLUDES= $(_TARGETPLATROOT)/SRC/inc;$(_COMMONOAKROOT)/inc;$(INCLUDES)

3.def文件

view plaincopy to clipboardprint?
;  
; Copyright (c) Microsoft Corporation.  All rights reserved.  
;  
;  
; Use of this source code is subject to the terms of the Microsoft end-user  
; license agreement (EULA) under which you licensed this SOFTWARE PRODUCT.  
; If you did not accept the terms of the EULA, you are not authorized to use  
; this source code. For a copy of the EULA, please see the LICENSE.RTF on your  
; install media.  
;  
 
 
EXPORTS  
    GIO_Init  
    GIO_Deinit  
    GIO_Open  
    GIO_Close  
    GIO_Read  
    GIO_Write  
    GIO_Seek  
    GIO_IOControl 
;
; Copyright (c) Microsoft Corporation.  All rights reserved.
;
;
; Use of this source code is subject to the terms of the Microsoft end-user
; license agreement (EULA) under which you licensed this SOFTWARE PRODUCT.
; If you did not accept the terms of the EULA, you are not authorized to use
; this source code. For a copy of the EULA, please see the LICENSE.RTF on your
; install media.
;


EXPORTS
 GIO_Init
 GIO_Deinit
 GIO_Open
 GIO_Close
 GIO_Read
 GIO_Write
 GIO_Seek
 GIO_IOControl
 

4.Reg文件

view plaincopy to clipboardprint?
[HKEY_LOCAL_MACHINE/Drivers/BuiltIn/IO]  
    "Prefix"="GIO" 
    "Index"=dword:1  
    "Dll"="IO.dll" 
    "Order"=dword:12 
[HKEY_LOCAL_MACHINE/Drivers/BuiltIn/IO]
    "Prefix"="GIO"
    "Index"=dword:1
    "Dll"="IO.dll"
    "Order"=dword:12
 

5.应用程序调用

view plaincopy to clipboardprint?
// GPIODEMODlg.cpp : implementation file  
//  
 
#include "stdafx.h"  
#include "GPIODEMO.h"  
#include "GPIODEMODlg.h"  
 
 
#ifdef _DEBUG  
#define new DEBUG_NEW  
#undef THIS_FILE  
static char THIS_FILE[] = __FILE__;  
#endif  
 
/////////////////////////////////////////////////////////////////////////////  
// CGPIODEMODlg dialog  
 
 
/************************************************************************/ 
//我们在这里手动添加GPIO测试相关的代码  
//定义相关IO control code，需要用到winioctl.h文件  
#include <winioctl.h>   
#define GIO_WRITE0  CTL_CODE(FILE_DEVICE_SERIAL_PORT, 2059, METHOD_BUFFERED, FILE_ANY_ACCESS)     
#define GIO_WRITE1  CTL_CODE(FILE_DEVICE_SERIAL_PORT, 2060, METHOD_BUFFERED, FILE_ANY_ACCESS)  
#define GIO_READ    CTL_CODE(FILE_DEVICE_SERIAL_PORT, 2061, METHOD_BUFFERED, FILE_ANY_ACCESS)  
//定义驱动句柄  
HANDLE m_hFile;   
//定义IO序号  
INT i=0;  
/************************************************************************/ 
 
 
 
 
 
CGPIODEMODlg::CGPIODEMODlg(CWnd* pParent /*=NULL*/)  
    : CDialog(CGPIODEMODlg::IDD, pParent)  
{  
    //{{AFX_DATA_INIT(CGPIODEMODlg)  
    m_state = _T("");  
    //}}AFX_DATA_INIT  
    // Note that LoadIcon does not require a subsequent DestroyIcon in Win32  
    m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);  
}  
 
void CGPIODEMODlg::DoDataExchange(CDataExchange* pDX)  
{  
    CDialog::DoDataExchange(pDX);  
    //{{AFX_DATA_MAP(CGPIODEMODlg)  
    DDX_Control(pDX, IDC_IONUM, m_ComboIOnum);  
    DDX_Text(pDX, IDC_EDIT1, m_state);  
    //}}AFX_DATA_MAP  
}  
 
BEGIN_MESSAGE_MAP(CGPIODEMODlg, CDialog)  
    //{{AFX_MSG_MAP(CGPIODEMODlg)  
    ON_BN_CLICKED(IDC_BUTTON1, OnButton1)  
    ON_BN_CLICKED(IDC_BUTTON2, OnButton2)  
    ON_BN_CLICKED(IDC_BUTTON3, OnButton3)  
    //}}AFX_MSG_MAP  
END_MESSAGE_MAP()  
 
/////////////////////////////////////////////////////////////////////////////  
// CGPIODEMODlg message handlers  
 
BOOL CGPIODEMODlg::OnInitDialog()  
{  
    CDialog::OnInitDialog();  
 
    // Set the icon for this dialog.  The framework does this automatically  
    //  when the application's main window is not a dialog  
    SetIcon(m_hIcon, TRUE);         // Set big icon  
    SetIcon(m_hIcon, FALSE);        // Set small icon  
      
    CenterWindow(GetDesktopWindow());   // center to the hpc screen  
 
    // TODO: Add extra initialization here  
 
 
/************************************************************************/ 
//我们在这里手动添加GPIO测试相关的代码  
//在这里我们去打开GPIO的驱动  
    m_hFile = CreateFile(TEXT("GIO1:"), GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0);  
    if (m_hFile == INVALID_HANDLE_VALUE)  
    {  
        MessageBox(_T("GPIOTEST"),_T("Can not open GPIO1!"),MB_OK);  
        return(FALSE);  
    }  
    else 
        MessageBox(_T("GPIOTEST"),_T("Open GPIO1 success!"),MB_OK);  
    m_ComboIOnum.SetCurSel(0);  
/************************************************************************/ 
 
 
    return TRUE;  // return TRUE  unless you set the focus to a control  
}  
 
 
/************************************************************************/ 
//我们在这里手动添加GPIO测试相关的代码  
void CGPIODEMODlg::OnButton1()   
{  
    // TODO: Add your control notification handler code here  
    DWORD dwReturn;  
    UpdateData(TRUE);  
    i=m_ComboIOnum.GetCurSel();  
    DeviceIoControl(m_hFile,GIO_WRITE1,&i,1,NULL,0,&dwReturn,NULL);  
}  
 
void CGPIODEMODlg::OnButton2()   
{  
    // TODO: Add your control notification handler code here  
    DWORD dwReturn;  
    UpdateData(TRUE);  
    i=m_ComboIOnum.GetCurSel();  
    DeviceIoControl(m_hFile,GIO_WRITE0,&i,1,NULL,0,&dwReturn,NULL);  
}  
 
void CGPIODEMODlg::OnButton3()   
{  
    // TODO: Add your control notification handler code here  
    DWORD dwReturn;  
    DWORD result;  
    UpdateData(TRUE);  
    i=m_ComboIOnum.GetCurSel();  
//SBC9261  
    DeviceIoControl(m_hFile,GIO_READ,&i,1,&result,1,&dwReturn,NULL);  
    if(result==1)  
     m_state=_T("GPIO input high:1");  
    else 
     m_state=_T("GPIO input low :0");  
 
//说明   
//在sbc6000x已经发布的光盘的IO0-IO5是由TSC2301音频芯片扩展的来的IO,在驱动中读到的result的bit[5-0]对应IO5-IO5,所以在这里我们对  
//result右移相应的bit位使得result的bit0代表相应IO的状态。即最终的result的bit0=1则相应的IO输入是高电平，bit0=0则相应的IO输入是低电平。  
/* 
    DeviceIoControl(m_hFile,GIO_READ,&i,1,&result,1,&dwReturn,NULL); 
    if(i<6) 
        result=(result>>i); 
    if(result==1) 
     m_state=_T("GPIO input high:1"); 
    else 
     m_state=_T("GPIO input low :0"); 
*/ 
    UpdateData(FALSE);  
}  
/************************************************************************/ 

 

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/yearafteryear/archive/2009/10/22/4711814.aspx

收录于
Win CE

当前文章被收录于：

Win CE
26 篇文章 0 人学习
订阅专栏 查看详情
标签
#wince #struct #microsoft #input #output
#file
AT91SAM9263 WINCE 6.0 R2驱动开发-6X6矩阵键盘驱动 1.原理图2.代码#include #include #include #include #include #include #include #include #include "matrixkey.h"#include "Oal_timer.h"#include "at91_pio.h"// Controller includes#i 阅读详情

相关推荐

Windows驱动开发WDM （5）- DeviceIoControl(直接方式交互"输出buffer"）

除了ReadFile和WriteFile外，还有一个函数可以让用户模式程序访问内核模式驱动：DeviceIoControl。这是经常用的一个API， 原型如下： BOOL WINAPI DeviceIoControl( _In_ HANDLE hDevice,//已经打开的设备 _In_ DWORD dwIoControlCode,控制码 _In_op

zj510的专栏 1万+

能够在keil4下运行的AT91SAM9260示例程序（含工程文件）

能够在keil4下运行的AT91SAM9260示例程序（含工程文件）原网站提供的只能在keil3下编译

OpenClaw SSH沙盒实战：构建AI代码执行的远程安全堡垒

在AI智能体开发中，代码执行安全是核心挑战。安全沙盒技术通过隔离机制，为AI工具调用划定安全边界，防止恶意代码对宿主系统造成破坏。其原理是在受限环境中运行不可信代码，确保所有操作被隔离，从而保障系统安全。这项技术的核心价值在于平衡AI的自主性与系统的可控性，广泛应用于自动化脚本执行、代码生成测试、数据处理等场景。本文聚焦OpenClaw的SSH后端，深入解析如何通过远程服务器构建物理隔离的沙盒环境，并结合OpenShell插件实现托管式沙盒与灵活的文件同步策略，为AI应用提供坚固的远程安全防线。

weixin_30718391的博客 516

AT91Sam9260的SPI

一，SPI的定义 SPI是串行外设接口（Serial Peripheral Interface）的缩写。 SPI，是一种高速的，全双工，同步的通信总线，并且在芯片的管脚上只占用四根线，具有简单易用的特性，如今越来越多的芯片集成了这种通信协议。 二、SPI的通信原理 通信原理很简单，它以主从方式工作，这种模式通常有一个主设备和一个或多个从设备，需要至少4根线，事实上3根也可以（单向传

fluency的博客 1011

25章 SPI—读写串行FLASH

SPI 协议简介 通讯协议(Serial Peripheral Interface)，即串行外围设备接口，是一种高速全双工的通信总线。它被广泛地使用在ADC、LCD 等设备与MCU 间，要求通讯速率较高的场合。 可与I2C 章节对比阅读，体会两种通讯总线的差异以及EEPROM 存储器与FLASH存储器的区别。 物理层 SPI 通讯使用3 条总线及片选线，3 条总线分别为SCK、MOSI、MISO,片选线为SS1、2、3 (1) ( Slave Select)：从设备选择信号线，常称为片选信号线，也称为NS

希望能对你有用 2549

2.6 基于SPI总线的SD卡驱动总结 ,at91

来自:http://blog.chinaunix.net/u1/58780/showart_673609.html 最近粗略的看了SD的Specifications，结合网上前人的代码，把SD卡跑通了。处理器是AT91SAM7X256，用SPI接口挂SD卡。SD卡的协议我看了两个版本，1.7和2.0。2.0版本比1.x多了支持HCSD（High CapacitySD），且多了些操作

LYJ个人博客，记录技术、八卦、生活，分享各种心得，期待与朋友们一同进步 3707

SPI总线知识总结

SPI总线知识总结

汽车以太网和SOA 5670

spi驱动框架全面分析，从master驱动到设备驱动

内核版本：linux2.6.32.2  硬件资源：s3c2440 参考：  韦东山SPI视频教程 内容概括：     1、I2C 驱动框架回顾     2、SPI 框架简单介绍     3、master 驱动框架         3.1 驱动侧         3.2 设备侧     4、SPI 设备驱动框架   4.1 设备层 4.2 驱动层     5、设备

漫不经心 1万+

windows driver - DeviceIoControl 用法

原文地址：https://www.cnblogs.com/lsh123/p/7354573.html 之前写过一篇关于通过DeviceIoControl函数来使应用程序与驱动程序通信的博客，这次再通过这个完整的代码来简要疏通总结一下。 　　这种通信方式，就是驱动程序和应用程序自定义一种IO控制码，然后调用DeviceIoControl函数，IO管理器会产生一个MajorFunction 为IRP_MJ_DEVICE_CONTROL（DeviceIoControl函数会产生此IRP），MinorFunc.

dragon_cdut的博客 2804

WinCE下GPIO（LED可参考）的流驱动开发（附源码，供下载参考）

WinCE下GPIO（LED可参考）的流驱动开发（附源码，供下载参考）   笔者接到导师任务，在WinCE系统下加载一个I/O口的流驱动来控制一个继电器开关，说白了就是来控制GPIO口的输入输出状态和端口电平的高低。现在手上的板子是友善公司的Tiny6410增强版。 首先，来上一张图来理一下做的思路。   在带有操作系统的基础上对芯片进行操作，是需要在驱动层中BSP中对GPIO文

u013550000的博客 658

AT91SAM9263 WINCE 6.0 R2驱动开发-官方BSP包EBOOT复位芯片解决

官方的BSP编译后EBOOT烧写进扳子后EBOOT会一直重启：串口打印信息如下：RomBOOT>INFO : Low Level Init : OKInit Nand flashStarting eboot ...Master Clock is 解决方法：在F:/WINCE600/PLATFORM/AT91SAM9263EK/SRC/BOOTLOADER/E

yearafteryear的专栏 1333

Windows 10驱动开发入门（三）：DeviceIoControl实现上层通讯

在这个例子中我们创建了一个设备对象，使用`DeviceIoControl` 来发送`IRP`，实现了上层程序和驱动之间的通讯。

haleycat的博客 1528

WINCE 流驱动的xx_IOControl

 前言       刚刚完成一个WINCE 下的I2C的流驱动,由于在读I2C 时要进行参数的传入和传出,所以其中的xx_IOControl必须要完成,像一些简单的传递单向数据的驱动,要xx_Read或xx_Write就可以实现.       之前没有写过xx_IOControl,所以参考了网上的代码又结合自己的软硬件环境,我现有的BSP 里已经实现了I2C 读写的基本函数,所以只

AlicePeter的专栏 4620

WinCE流设备驱动简介及GPIO驱动的实现

转载：WinCE流设备驱动简介及GPIO驱动的实现流设备驱动实际上就是导出标准的流接口函数的驱动，这是文档上面的定义。在WinCE中，所有的流设备都导出流设备接口，这样WinCE中的Device Manager可以加载和管理这些流设备驱动。流设备驱动的架构如图：  首先我声明一下，这个图是我抄的，呵呵。在WinCE启动的时候，OAL(OAL.exe)首先加载kernel.dll，然

dengxin123的专栏 718

实战DeviceIoControl 之六：访问物理端口

Q 在NT/2000/XP中，如何读取CMOS数据？ Q 在NT/2000/XP中，如何控制speaker发声？ Q 在NT/2000/XP中，如何直接访问物理端口？ A 看似小小问题，难倒多少好汉！ NT/2000/XP从安全性、可靠性、稳定性上考虑，应用程序和操作系统是分开的，操作系统代码运行在核心态，有权访问系统数据和硬件，能执行特权指令；应用程序运行在用户态，能够使用的接口和...

weixin_30512043的博客 164
上一篇： wince6.0 下的流驱动开发范例
下一篇： WinCE 流驱动一步一步来
点赞 0
评论 0
书签 书签 0
harkspan
harkspan
博客等级 码龄18年 65粉丝 0原创
+ 关注 专栏目录 订阅专栏
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值