博客园_.cpp的嵌入式生活

PB编写看门狗流式驱动

2010-11-16T03:35:00Z

(1) 建立驱动程序目录
在 C:\WINCE500\PLATFORM\mini2440\Src\Drivers\下建立 WDTDriver目录，并在dirs文件中加入此目录，使系统编译 bsp 的时候可以编译这个文件

(2)为 WDT驱动创建 Makefile文件

可以参考其他驱动程序示例创建 Makefile文件。在 WDTDriver目录中建立 makefile文件，内容如下：

#
# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
# file to this component.  This file merely indirects to the real make file
# that is shared by all the components of Peg
#
!INCLUDE $(_MAKEENVROOT)\makefile.def

(3)为 WDT驱动创建 source 文件

可以参考其他驱动程序实例创建source 文件，内容如下：

!if 0
    File:   sources
     Copyright (c) 1995-2002 Microsoft Corporation.  All rights reserved.
!endif

!if "$(BSP_NOWATCHDOG)" == "1"
SKIPBUILD=1
!endif

RELEASETYPE=PLATFORM
TARGETNAME=WDTDriver
TARGETTYPE=DYNLINK
DLLENTRY=DllEntry

TARGETLIBS= \
    $(_COMMONSDKROOT)\lib\$(_CPUINDPATH)\coredll.lib \

MSC_WARNING_LEVEL = $(MSC_WARNING_LEVEL) /W3 /WX
      
SOURCES= wdt.cpp

(4)编写wdt.def导出 Dll 符号

可以参考其他驱动程序示例创建 wdt.def文件。

;
; Windows WDT Driver. Written by yubaolee(.cpp/anglecloudy)
LIBRARY WDT
EXPORTS
	WDT_Close
	WDT_Deinit
	WDT_Init
	WDT_IOControl
	WDT_Open
	WDT_PowerDown
	WDT_PowerUp
	WDT_Read
	WDT_Seek
	WDT_Write

(5)把驱动加入内核在配置文件 platform.bib中加入以下内容：

IF BSP_NOWATCHDOG !
	WDTDriver.dll             $(_FLATRELEASEDIR)\WDTDriver.dll				NK	SH
ENDIF BSP_NOWATCHDOG !

(6)把 LED 驱动加入注册表在注册表文件 platform.reg中加入以下内容：

IF BSP_NOWATCHDOG !
[HKEY_LOCAL_MACHINE\Drivers\BuiltIn\WDTDriver]
   "Prefix"="WDT"
   "Dll"="WDTDriver.dll"
   "Order"="200"
ENDIF BSP_NOWATCHDOG !

(7)编写代码：

//wdt.h文件
#ifndef __WDT_H_
#define __WDT_H_

#ifdef __cplusplus
extern "C" {
#endif

DWORD WDT_Init(DWORD dwContext);
DWORD WDT_Open(DWORD hDeviceContext, DWORD AccessCode, DWORD ShareMode);
DWORD WDT_Write(DWORD hOpenContext, LPCVOID pSourceBytes, DWORD NumberOfBytes);

DWORD WDT_Read(DWORD hOpenContext, LPVOID pBuffer, DWORD Count);
DWORD WDT_Seek(DWORD hOpenContext, long Amount, DWORD Type);

BOOL WDT_IOControl(DWORD hOpenContext, DWORD dwCode, PBYTE pBufIn, DWORD dwLenIn, PBYTE pBufOut, DWORD dwLenOut, PDWORD pdwActualOut);
BOOL WDT_Close(DWORD hOpenContext);
BOOL WDT_Deinit(DWORD hDeviceContext);
void WDT_PowerUp(DWORD hDeviceContext);
void WDT_PowerDown(DWORD hDeviceContext);

#ifdef __cplusplus
}
#endif
#endif

//wdt.cpp源码
#include <windows.h>
#include <nkintr.h>
#include <pm.h>
#include "pmplatform.h"
#include "Pkfuncs.h"
#include "s2440.h"

#include "wdt.h"

volatile WATCHreg	*s2440WDT = 0;

static BOOL FeedIt()
{

	s2440WDT->rWTCON = 0x8021; // Init Value
	s2440WDT->rWTDAT = s2440WDT->rWTCNT = 0xFEA9;
	s2440WDT->rWTCON = ( 1 << 0) | (0x03 << 3 ) | (1 << 5) | (0x5A << 8);
	RETAILMSG(1,(TEXT("WDT: feed ok\r\n")));
	return TRUE;
}

BOOL WINAPI  
DllEntry(HANDLE	hinstDLL, 
			DWORD dwReason, 
			LPVOID  Reserved/* lpvReserved */)
{
	switch(dwReason)
	{
	case DLL_PROCESS_ATTACH:
		DEBUGREGISTER((HINSTANCE)hinstDLL);
		break;
	case DLL_THREAD_ATTACH:
		break;
	case DLL_THREAD_DETACH:
		break;
	case DLL_PROCESS_DETACH:
		break;
#ifdef UNDER_CE
	case DLL_PROCESS_EXITING:
		break;
	case DLL_SYSTEM_STARTED:
		break;
#endif
	}

	return TRUE;
}


BOOL WDT_Deinit(DWORD hDeviceContext)
{
	
	return TRUE;
}
 

BOOL WDT_IOControl(DWORD hOpenContext, 
				   DWORD dwCode, 
				   PBYTE pBufIn, 
				   DWORD dwLenIn, 
				   PBYTE pBufOut, 
				   DWORD dwLenOut, 
				   PDWORD pdwActualOut)
{
 
	return 0;
} 

void WDT_PowerDown(DWORD hDeviceContext)
{
} 

void WDT_PowerUp(DWORD hDeviceContext)
{
} 

DWORD WDT_Read(DWORD hOpenContext, LPVOID pBuffer, DWORD Count)
{
	return 0;
} 

DWORD WDT_Seek(DWORD hOpenContext, long Amount, DWORD Type)
{
	return 0;
} 

DWORD WDT_Init(DWORD dwContext)
{

  do {
		s2440WDT = (volatile WATCHreg *) VirtualAlloc(0,sizeof(WATCHreg),MEM_RESERVE, PAGE_NOACCESS);
		if (s2440WDT == 0) {
			break;
		}

		if (!VirtualCopy((PVOID)s2440WDT,(PVOID)(WATCH_BASE),sizeof(WATCHreg),PAGE_READWRITE | PAGE_NOCACHE )) {
			break;
		}

		//ret = TRUE;
		RETAILMSG(1,(TEXT("WDT: VirtualAlloc ok\r\n")));
	} while (0);
	RETAILMSG(1,(TEXT("WDT: Init\r\n")));
	return TRUE;
}

BOOL WDT_Close(DWORD hOpenContext)
{
	if (s2440WDT) {
		VirtualFree((void*)s2440WDT, sizeof(WATCHreg), MEM_RELEASE);
		s2440WDT = 0;
		RETAILMSG(1,(TEXT("WDT: VirtualFree ok\r\n")));
	}
	RETAILMSG(1,(TEXT("WDT: Close\r\n")));
	return TRUE;
} 

// Beaf is here

DWORD WDT_Open(DWORD hDeviceContext, DWORD AccessCode, DWORD ShareMode)
{
	RETAILMSG(1,(TEXT("WDT: Open\r\n")));
	return TRUE;
} 

DWORD WDT_Write(DWORD hOpenContext, LPCVOID pSourceBytes, DWORD NumberOfBytes)
{
	RETAILMSG(1,(TEXT("WDT: Write\r\n")));
	FeedIt();
	return TRUE;
}

(8)这时打开PB 在FileView视图mini2440/src/Drivers/就可以看到WDT的工程了，右键Build Current Project,没有错误的话，就可以生成WDT.DLL文件了，再生成一下系统就行了。

-----------------------------------.CPP---------------------------------------------------------------

@written by .cpp

http://hi.baidu.com/anglecloudy

http://www.cnblogs.com/DotCpp

本文链接

mini2440 看门狗驱动 WatchDog Driver

2010-09-15T07:46:00Z

友善官方提供的看门狗长时间运行后，会造成内存泄漏，从而导致系统重启，给应用开发人员带来了一些麻烦。

我重新写了一下看门狗的驱动，很简单。就是把原有的每次喂狗时分配内存改为初始化时分配。

volatile WATCHreg	*s2440WDT = 0;

static BOOL FeedIt()
{

	s2440WDT->rWTCON = 0x8021; // Init Value
	s2440WDT->rWTDAT = s2440WDT->rWTCNT = 0xFEA9;
	s2440WDT->rWTCON = ( 1 << 0) | (0x03 << 3 ) | (1 << 5) | (0x5A << 8);
	RETAILMSG(1,(TEXT("WDT: feed ok\r\n")));
	return TRUE;
}

BOOL WINAPI  
DllEntry(HANDLE	hinstDLL, 
			DWORD dwReason, 
			LPVOID  Reserved/* lpvReserved */)
{
	switch(dwReason)
	{
	case DLL_PROCESS_ATTACH:
		DEBUGREGISTER((HINSTANCE)hinstDLL);
		break;
	case DLL_THREAD_ATTACH:
		break;
	case DLL_THREAD_DETACH:
		break;
	case DLL_PROCESS_DETACH:
		break;
#ifdef UNDER_CE
	case DLL_PROCESS_EXITING:
		break;
	case DLL_SYSTEM_STARTED:
		break;
#endif
	}

	return TRUE;
}


BOOL WDT_Deinit(DWORD hDeviceContext)
{
	
	return TRUE;
}
 

BOOL WDT_IOControl(DWORD hOpenContext, 
				   DWORD dwCode, 
				   PBYTE pBufIn, 
				   DWORD dwLenIn, 
				   PBYTE pBufOut, 
				   DWORD dwLenOut, 
				   PDWORD pdwActualOut)
{
 
	return 0;
} 

void WDT_PowerDown(DWORD hDeviceContext)
{
} 

void WDT_PowerUp(DWORD hDeviceContext)
{
} 

DWORD WDT_Read(DWORD hOpenContext, LPVOID pBuffer, DWORD Count)
{
	return 0;
} 

DWORD WDT_Seek(DWORD hOpenContext, long Amount, DWORD Type)
{
	return 0;
} 

DWORD WDT_Init(DWORD dwContext)
{

  do {
		s2440WDT = (volatile WATCHreg *) VirtualAlloc(0,sizeof(WATCHreg),MEM_RESERVE, PAGE_NOACCESS);
		if (s2440WDT == 0) {
			break;
		}

		if (!VirtualCopy((PVOID)s2440WDT,(PVOID)(WATCH_BASE),sizeof(WATCHreg),PAGE_READWRITE | PAGE_NOCACHE )) {
			break;
		}

		//ret = TRUE;
		RETAILMSG(1,(TEXT("WDT: VirtualAlloc ok\r\n")));
	} while (0);
	RETAILMSG(1,(TEXT("WDT: Init\r\n")));
	return TRUE;
}

BOOL WDT_Close(DWORD hOpenContext)
{
	if (s2440WDT) {
		VirtualFree((void*)s2440WDT, sizeof(WATCHreg), MEM_RELEASE);
		s2440WDT = 0;
		RETAILMSG(1,(TEXT("WDT: VirtualFree ok\r\n")));
	}
	RETAILMSG(1,(TEXT("WDT: Close\r\n")));
	return TRUE;
} 

// Beaf is here

DWORD WDT_Open(DWORD hDeviceContext, DWORD AccessCode, DWORD ShareMode)
{
	RETAILMSG(1,(TEXT("WDT: Open\r\n")));
	FeedIt();
	return TRUE;
} 

DWORD WDT_Write(DWORD hOpenContext, LPCVOID pSourceBytes, DWORD NumberOfBytes)
{
	RETAILMSG(1,(TEXT("WDT: Write\r\n")));
	FeedIt();
	return TRUE;
}

本文链接

WINCE重新启动

2010-08-11T02:15:00Z

因为要在WINCE上面开发一个系统，监测数据。长时间运行下去容易导致死机。所以设定定时重启。认真分析与查阅相关资料后，发现下面几种方法：

一、使用SetSystemPowerState，通过测试后发现该方法重启的效果并不理想，有点像WINDOWS的注销而不是断电重启。

#ifndef POWER_STATE_RESET
#define POWER_STATE_RESET DWORD(0x00800000)
#endif

typedef BOOL (*SetSystemPowerState)(   
									LPCWSTR psState,
									DWORD StateFlags,
									DWORD Options
                                    );



//在函数中调用如下：
HINSTANCE hModule = LoadLibrary(_T("Coredll.dll"));
SetSystemPowerState f = (SetSystemPowerState)::GetProcAddress(hModule, TEXT("SetSystemPowerState"));
f(NULL, POWER_STATE_RESET, 0);
::FreeLibrary(hModule);

二、使用看门狗，因为看门狗必须定时喂食，所以我在调用时不给它喂食就会造成系统重启。我用的EMD9263的板子，重启代码如下：

#define AT91SAM9263_ENABLE_WATCHDOG			2400
#define AT91SAM9263_DISABLE_WATCHDOG		2401
#define AT91SAM9263_CLEAR_WATCHDOG			2402
#define FILE_DEVICE_DATALINK            0x00000005
#define METHOD_BUFFERED                 0
#define FILE_WRITE_ACCESS         ( 0x0002 )    // file & pipe
#define CTL_CODE( DeviceType, Function, Method, Access ) (                 \
	((DeviceType) << 16) | ((Access) << 14) | ((Function) << 2) | (Method) \
	)

#define IOCTL_ENABLE_WATCHDOG CTL_CODE(FILE_DEVICE_DATALINK, AT91SAM9263_ENABLE_WATCHDOG, METHOD_BUFFERED, FILE_WRITE_ACCESS)
#define IOCTL_DISABLE_WATCHDOG CTL_CODE(FILE_DEVICE_DATALINK, AT91SAM9263_DISABLE_WATCHDOG, METHOD_BUFFERED, FILE_WRITE_ACCESS)
#define IOCTL_CLEAR_WATCHDOG CTL_CODE(FILE_DEVICE_DATALINK, AT91SAM9263_CLEAR_WATCHDOG, METHOD_BUFFERED, FILE_WRITE_ACCESS)


//调用如下:
 HANDLE  hFileWatchdog= CreateFile(_T("DOG1:"), 
		                               GENERIC_READ | GENERIC_WRITE,
		                                0,
										NULL, 
										OPEN_EXISTING,
										FILE_ATTRIBUTE_NORMAL,
										NULL);
	if (hFileWatchdog != INVALID_HANDLE_VALUE)
	{
		DWORD dwReturn;
		BOOL ret=::DeviceIoControl(hFileWatchdog,IOCTL_ENABLE_WATCHDOG,NULL,0,NULL,0,&dwReturn,NULL);
		if(ret!=TRUE)
		{
			::CloseHandle(hFileWatchdog);
		}
	}

在实际运用中，我用的是第二种方法。第一种方法可以适当使用。

@written by .cpp

http://www.cnblogs.com/dotcpp

http://hi.baidu.com/anglecloudy

本文链接

2440 WinCE操作GPIO

2010-07-29T09:06:00Z

Windows CE系统将GPIO的实地址(例如2440的GPIO的基地址为0x56000000)映射到虚拟地址空间（GPIO对应为0xB1600000），这样，通过对这段虚拟地址空间的操作，就能够完成对GPIO或者其他片内资源的控制、输入输出工作。要操作一个平台的GPIO，在其对应BSP中按照基地址，找到虚拟地址，并且找到方便操作这个地址的数据结构就可以了，关键函数就是 VirtualAlloc和VirtualCopy。下面以操作Samsung S3C2440的GPIO为例，讲述这个步骤：
1.首先在BSP中的s2440.h文件，找到虚拟地址映射以及操作GPIO的寄存器结构体(这个在自己制作一些特殊设备的BSP时，会依据需要而发生更改)

#define IOP_BASE      0xB1600000 // 0x56000000
typedef struct  {
	unsigned int  rGPACON;			// 00
	unsigned int  rGPADAT;
	unsigned int  rPAD1[2];

	unsigned int  rGPBCON;			// 10
	unsigned int  rGPBDAT;
	unsigned int  rGPBUP;
	unsigned int  rPAD2;

	unsigned int  rGPCCON;			// 20
	unsigned int  rGPCDAT;
	unsigned int  rGPCUP;
	unsigned int  rPAD3;

	unsigned int  rGPDCON;			// 30
	unsigned int  rGPDDAT;
	unsigned int  rGPDUP; 
	unsigned int  rPAD4;

	unsigned int  rGPECON;			// 40
	unsigned int  rGPEDAT;
	unsigned int  rGPEUP;
	unsigned int  rPAD5;

	unsigned int  rGPFCON;			// 50
	unsigned int  rGPFDAT;
	unsigned int  rGPFUP; 
	unsigned int  rPAD6;

	unsigned int  rGPGCON;			// 60
	unsigned int  rGPGDAT;
	unsigned int  rGPGUP; 
	unsigned int  rPAD7;

	unsigned int  rGPHCON;			// 70
	unsigned int  rGPHDAT;
	unsigned int  rGPHUP; 
	unsigned int  rPAD8;

	unsigned int  rMISCCR;			// 80
	unsigned int  rDCKCON;		
	unsigned int  rEXTINT0;
	unsigned int  rEXTINT1;		
	unsigned int  rEXTINT2;			// 90
	unsigned int  rEINTFLT0;
	unsigned int  rEINTFLT1;
	unsigned int  rEINTFLT2;
	unsigned int  rEINTFLT3;		// A0
	unsigned int  rEINTMASK;
	unsigned int  rEINTPEND;
	unsigned int  rGSTATUS0;		// AC
	unsigned int  rGSTATUS1;		// B0
	unsigned int  rGSTATUS2;		// B4 ;;; SHL
	unsigned int  rGSTATUS3;		// B8
	unsigned int  rGSTATUS4;		// BC

	unsigned int  rFLTOUT;			// C0
	unsigned int  rDSC0;
	unsigned int  rDSC1;
	unsigned int  rMSLCON;

	unsigned int  rGPJCON;			// D0
	unsigned int  rGPJDAT;
	unsigned int  rGPJUP;
	unsigned int  rPAD9;

}IOPreg;

二、因为我用的mini2440开发板的GPB0接在蜂鸣器上，所以我以操作GPB0为例编写代码。这样给GPB0一个高电平，那么蜂鸣器就会响，反之蜂鸣器就会停止发声

#ifdef __cplusplus
extern "C"
{
#endif
	BOOL VirtualCopy( PVOID, PVOID, DWORD, DWORD );
#ifdef __cplusplus
}
#endif


void GPIO()        //通过GPIO控制蜂鸣器
{
	volatile IOPreg *v_pIORegs;
	v_pIORegs = (volatile IOPreg *)VirtualAlloc(0, sizeof(IOPreg), MEM_RESERVE, PAGE_NOACCESS);
	if(v_pIORegs)
	{
		if(VirtualCopy((PVOID)v_pIORegs, (PVOID)IOP_BASE, sizeof(IOPreg), PAGE_READWRITE | PAGE_NOCACHE))
		{
			v_pIORegs->rGPBCON = 1;                    //将GPB0设置为OUTPUT
			v_pIORegs->rGPBDAT = 0x3ff;               //设置为高电平，蜂鸣器发声
			Sleep(3000);
			v_pIORegs->rGPBDAT = 0;                     //恢复为低电平，蜂鸣器停止发声
		}

		VirtualFree((LPVOID)v_pIORegs, 0, MEM_RELEASE);
		v_pIORegs = NULL;
	}
}

@written by .cpp

百度空间：http://hi.baidu.com/anglecloudy

博客园：http://www.cnblogs.com/dotcpp

本文链接

获取系统当前正在运行的全部进程

2010-05-05T06:42:00Z

#include <windows.h>
#include <TlHelp32.h>
#include <stdio.h>

int main()
{
	PROCESSENTRY32 pe32 = { sizeof(PROCESSENTRY32) };
	HANDLE hProcessSnap = ::CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
	if (hProcessSnap == INVALID_HANDLE_VALUE)
	{
		printf("CreateIoolhelp32snapshot error\n");
		return -1;
	}

	bool bMore = ::Process32First(hProcessSnap, &pe32);
	while(bMore)
	{
		printf("process name : %s \n", pe32.szExeFile);
		printf("proecess id : %u \n........................\n", pe32.th32ProcessID);
		bMore = ::Process32Next(hProcessSnap, &pe32);
	}
	CloseHandle(hProcessSnap);

	system("pause");
}

本文链接

博客园网站有病毒？

2010-04-17T02:25:00Z

今天一朋友在QQ上发来博客园一文章让我看，拿QQ去点，就是下图。狂汗。

图上的文章为windows mobile方面的大牛：http://www.cnblogs.com/procoder/archive/2010/04/17/Programming_Windows_Phone_7_Introduction.html

不知道博客园的工作人员看了怎么想，唉...

本文链接

VC按字符读取文件

2010-04-14T02:26:00Z

#pragma once
#include "Common.h"
/************************************************
  类名：CCableFile
  功能：用于普通文件读取
*************************************************/
class CCableFile
{
private:
    FILE* m_file;
    CCommon m_comm;
public:
    CCableFile(void);
    ~CCableFile(void);

    BOOL OpenFile(const char* pszFile="NandFlash\\LogInfo.log", BOOL bRead=FALSE);
    void CloseFile();
    BOOL ReadLine( CString& szLine );
    BOOL WriteLine(CString szLine);
    BOOL WriteLine(char* pszTxt, int nTxt);

};

#include "StdAfx.h"
#include "CableFile.h"

#define BUFFERLEN 50

CCableFile::CCableFile(void)
{
    m_file = NULL;
}

CCableFile::~CCableFile(void)
{
}

BOOL CCableFile::OpenFile(const char* pszFile/*=NandFlash\\LogInfo.log*/, BOOL bRead/*=FALSE*/)
{
    if (bRead)
    {
        m_file = fopen(pszFile, "r");
    }
    else
    {
        m_file = fopen(pszFile, "a" );
    }
    if (m_file == NULL)
    {
        return FALSE;
    }
    else
        return TRUE;
}

void CCableFile::CloseFile()
{
    if (m_file != NULL)
    {
        fclose(m_file);
        m_file = NULL;
    }
}

BOOL CCableFile::ReadLine( CString& szLine )
{
    szLine="";
    int pos = 0;
    char ch;
    WCHAR* pwTxt;
    char szTxt[BUFFERLEN];
    memset(szTxt, 0, BUFFERLEN);
    while ((ch =fgetc(m_file))&& (ch!= EOF)&&(ch!='\n'))
    {
        if(pos >= BUFFERLEN -1)
        {
            m_comm.ToWideString(pwTxt, szTxt, pos, TRUE);
            szLine +=pwTxt;
            pos = 0;
            memset(szTxt, 0, BUFFERLEN);
            DELPOINTER(pwTxt);
        }
        szTxt[pos] = ch;
        pos ++;
    }

    if (pos >0)
    {
        m_comm.ToWideString(pwTxt, szTxt, pos, TRUE);
        szLine +=pwTxt;
        DELPOINTER(pwTxt);
    }

    if (szLine.GetLength() < 1)  
        return FALSE;
    else 
        return TRUE;
    
}

BOOL CCableFile::WriteLine( char* pszTxt, int nTxt )
{
    int nLen = fwrite(pszTxt, sizeof(char), nTxt, m_file);
    fflush(m_file);
    return (nLen == nTxt);
}

BOOL CCableFile::WriteLine( CString szLine )
{
    char* pTxt;
    int nLen = m_comm.ToMultiBytes(pTxt,
                                                              szLine.GetBuffer(szLine.GetLength()), 
                                                              szLine.GetLength(), 
                                                              FALSE);
    BOOL bWrite =WriteLine(pTxt, nLen);
    delete[] pTxt;
    pTxt = NULL;
    return bWrite;
}

下面是多字符与宽字符互相转化的封装类：

#pragma once

/***********************************************************************
 类名：全局通用类
 功能：封装一些基本操作，如字符类型转换等
************************************************************************/
class CCommon
{
public:
    /***********************************************************************
     功能：将多字符数组转成宽字符数组
     参数：pwStr：目标宽字符指针；
               pStr：源多字符指针；
               len：源数组长度；
               IsEnd：是否加'\0'
     返回：转换后的宽字符数组长度
    *************************************************************************/
    int ToWideString(WCHAR* &pwStr, const char* pStr, int len, BOOL IsEnd);

    /***********************************************************************
     功能：将宽字符数组转成多字符数组
     参数：pStr：目标多字符指针；
               pwStr：源宽字符指针；
               len：源数组长度
               IsEnd：是否加'\0'
     返回：转换后的多字符数组长度
    *************************************************************************/
    int ToMultiBytes(char* &pStr, const WCHAR* pwStr, int len, BOOL IsEnd);

};

#include "StdAfx.h"
#include "Common.h"

int CCommon::ToWideString( WCHAR* &pwStr, const char* pStr, int len, BOOL IsEnd)
{
    ASSERT_POINTER(pStr, char);
    ASSERT(len >= 0 || len == -1);

    int nWideLen = MultiByteToWideChar(CP_ACP, 0, pStr, len, NULL, 0);
    if (len == -1)
    {
        --nWideLen;
    }
    if (nWideLen == 0)
    {
        return 0;
    }

    if (IsEnd)
    {
        pwStr = new WCHAR[(nWideLen+1)*sizeof(WCHAR)];
        ZeroMemory(pwStr, (nWideLen+1)*sizeof(WCHAR));
    }
    else
    {
        pwStr = new WCHAR[nWideLen*sizeof(WCHAR)];
        ZeroMemory(pwStr, nWideLen*sizeof(WCHAR));
    }
    
    MultiByteToWideChar(CP_ACP, 0, pStr, len, pwStr, nWideLen);
    return nWideLen;
}

int CCommon::ToMultiBytes( char* &pStr, const WCHAR* pwStr, int len, BOOL IsEnd)
{
    ASSERT_POINTER(pwStr, WCHAR) ; 
    ASSERT( len >= 0 || len == -1 ) ; 

    int nChars = WideCharToMultiByte(CP_ACP, 0, pwStr, len, NULL, 0, NULL, NULL);
    if (len == -1)
    {
        --nChars;
    }

    if (nChars == 0)
    {
        return 0;
    }

    if(IsEnd)
    {
        pStr = new char[nChars+1];
        ZeroMemory(pStr, nChars+1);
    }
    else
    {
        pStr = new char[nChars];
        ZeroMemory(pStr, nChars);
    }

    WideCharToMultiByte(CP_ACP, 0, pwStr, len, pStr, nChars, NULL, NULL);
    return nChars;
}

本文链接

字符数组十六进制显示

2010-03-02T15:58:00Z

ShowRecvMessage(char* pszMessage, int nLength)
{
            CString strShow;
        LPTSTR p;
        TCHAR szText[300];
        ZeroMemory(szText, 300);
        p = szText;
        for (int i = 0; i< nLength; i++)
        {
            p+= wsprintf(p, TEXT("%.2x"), pszMessage[i]);  //这部分为关键部分
        }
        strShow.Format(_T("%s\r\n"), szText);
    }
    
    CEdit* pEdit =(CEdit*)AfxGetMainWnd()->GetDlgItem(IDC_EDIT_SHOWMSG);
    pEdit->SetFocus();
    pEdit->SetSel(-1, -1);
    pEdit->ReplaceSel(strShow);
}

本文链接

Winsock五种I/O模型的性能分析【转】

2010-02-21T07:06:00Z

注：本文转http://blog.pfan.cn/xman/45130.html

五种I/O模型的性能分析

重叠I/O 模型的另外几个优点在于，微软针对重叠I/O 模型提供了一些特有的扩展函数。当使用重叠I/O 模型时，可以选择使用不同的完成通知方式。

采用事件对象通知的重叠I/O 模型是不可伸缩的，因为针对发出WSAWaitForMultipleEvents 调用的每个线程，该I/O 模型一次最多都只能支持6 4 个套接字。假如想让这个模型同时管理不止64 个套接字，必须创建额外的工作者线程，以便等待更多的事件对象。因为操作系统同时能够处理的事件对象是有限的，所以基于事件对象的I/O 模型不具备伸缩性。

使用完成例程通知的重叠I/O 模型，因为以下几个原因，也不是开发高性能服务器的最佳选择。首先，许多扩展功能不允许使用APC （Asyncroneus Procedure Call ，异步过程调用）完成通知。其次，由于APC 在系统内部特有的处理机制，应用程序线程可能无限等待而得不到完成通知。当一个线程处于“ 可警告状态” 时，所有挂起的APC 按照先进先出的顺序（FIFO ）接受处理。现在考虑这样一种情况，服务器已经建立起了一个连接，并且调用含有完成例程指针的WSARecv 投递了一个重叠I/O 请求。当有数据到达时（即I/O 完成时），完成例程执行并且再次调用WSARecv 抛出另外一个重叠I/O 请求。一个APC 抛出的I/O 操作需要一定的时间才能完成，所以这期间可能另外一个完成例程等待执行（比如本次WSARecv 还没接收完时，又有一个新的客户接入并发来数据），因为还有更多的数据需要读取（上一个客户发来的数据尚未读完）。只要（投递WSARecv 的）那个套接字上还有“ 未决” （未接收完）的数据，就会导致调用线程长久阻塞。

基于完成端口通知的重叠I/O 模型是Windows NT 系统提供的一个真正支持高伸缩性的I/O 模型。在上一章中，探讨了Winsock 几种常见的I/O 模型，并且说明了当应对大规模客户连接时，完成端口是最佳的选择，因为它提供了最好的伸缩性。

对不同Winsock I/O 模型的性能测试结果如图1 所示。其中服务器采用Pentium 4 1.7 GHz Xeon 的CPU ，768M 内存；客户端有3 台PC ，配置分别是Pentium 2 233MHz ，128 MB 内存，Pentium 2 350 MHz ，128 MB 内存，Itanium 733 MHz ，1 GB 内存。服务器、客户端安装的操作系统都是Windows XP 。

图1 不同I/O 模型的性能比较

1. 分析图表1 提供的测试结果可知，在所用的I/O 模型中，阻塞模式性能最差。这个测试程序中，服务器为每个客户创建两个线程：一个负责处理数据的接收，一个负责处理数据的发送。在多次测试中的共同问题就是，阻塞模式难以应对大规模的客户连接，因为它在创建线程上耗费了太多的系统资源。因此，服务器创建太多的线程后，再调用CreateThread 函数时，将返回ERROR_NOT_ENOUGH_MEMORY 的错误，这个错误码提示内存不够。那些发出连接请求的客户则收到WSAECONNREFUSED 的错误提示，表示连接的尝试被拒绝。

让我们来看看监听函数listen ，其原型如下：

WINSOCK_API_LINKAGE int WSAAPI listen （SOCKET s, int backlog ）;

参数一s 已绑定了地址的监听套接字。

参数二backlog 指定了正在等待连接的最大队列长度。

参数backdog 非常重要, 因为完全可能同时出现几个对服务器的连接请求。例如，假定backlog 参数为2 时有三个客户机同时发出连接请求，那么前两个会被放在一个“ 等待处理” 队列中，以便应用程序依次为它们提供服务。而第三个连接的请求就会造成一个WSAECONNREFUSED 错误。一旦服务器接受了一个连接请求，那个连接请求就会从队列中删去，以便可以继续接收其他客户发出的连接请求。即当一个连接请求到来时队列已满，那么客户将收到一个WSAECONNREFUSED 错误。而backlog 参数本身的大小就存在着限制，这个限制是由协议提供者决定的。

故阻塞模式下，由于系统资源的限制，其并发处理量是极难突破的。

2. 非阻塞模式表现出的性能要比阻塞模式稍好，但是占用了太多的CPU 处理时间。测试服务器将所有客户对应的socket 分类放到FD_SET 集合中，然后调用select 函数筛选出对应集合中有事件发生的socket ，并对集合更新。接下来调用FD_ISSET 宏重新判断一个套接字是否在原来加入的FD_SET 集合中。随着客户连接数量的增多，这种模型的局限性逐渐凸现。仅仅为了判断一个套接字是否有网络事件发生，就需要对集合FD_SET 执行一次遍历! 使用迭代搜索来对select 更新的FD_SET 进行扫描，性能可以得到一些提升。瓶颈在于，服务器必须能够很快地扫描出FD_SET 集合中的有网络事件发生的套接字的相关信息。针对这个问题，可以使用更复杂的扫描算法，如哈希搜索，它的效率是极高的。还需要注意的一个问题就是，非分页池（即直接在物理内存中分配的内存）的使用极高。这是因为AFD （Ancillary Function Driver, 由afd.sys 提供的支持Windows Sockets 应用程序的底层驱动程序，其中运行在内核模式下afd.sys 驱动程序主要管理Winsock TCP/IP 通信）和TCP 都将使用I/O 缓存，因为服务器读取数据的速度是有限的，相对于CPU 的处理速度而言，I/O 基本是零字节的吞吐量。

3. 基于Windows 消息机制的WSAAsyncSelect 模型能够处理一定的客户连接量，但是扩展性也不是很好。因为消息泵很快就会阻塞，降低了消息处理的速度。在几次测试中，服务器只能处理大约1/3 的客户端连接。过多的客户端连接请求都将返回错误提示码WSAECONNREFUSED ，说明服务器不能及时处理FD_ACCEPT 消息导致连接失败，这样监听队列中待处理的连接请求不致于爆满。然而，通过上表中的数据可以发现，对那些已经建立的连接，其平均吞吐量也是极低的（即使对于那些对比特率进行了限制的客户也如此）。

4. 基于事件通知的WSAEventSelect 模型表现得出奇的不错。在所有的测试中，大多数时候，服务器基本能够处理所有的客户连接，并且保持着较高的数据吞吐量。这种模型的缺点是，每当有一个新连接时，需要动态管理线程池，因为每个线程只能够等待64 个事件对象。当客户连接量超过64 个后再有新客户接入时，需要创建新的线程。在最后一次测试中，建立起了超过45,000 个的客户连接后，系统响应速度变得非常缓慢。这时由于为处理大规模的客户连接创建了大量的线程，占用了过多的系统资源。791 个线程基本达到了极限，服务器不能再接受更多的连接了，原因是WSAENOBUFS ：无可用的缓冲区空间，套接字无法创建。另外，客户端程序也达到了极限，不能维持已经建立的连接。

使用事件通知的重叠I/O 模型和WSAEventSelect 模型在伸缩性上差不多。这两种模型都依赖于等待事件通知的线程池，处理客户通信时，大量线程上下文的切换是它们共同的制约因素。重叠I/O 模型和WSAEventSelect 模型的测试结果很相似，都表现得不错，直到线程数量超过极限。

5. 最后是针对基于完成端口通知的重叠I/O 模型的性能测试，由上表中数据可以看出，它是所有I/O 模型中性能最佳的。内存使用率（包括用户分页池和非分页池）和支持的客户连接量与基于事件通知的重叠I/O 模型和WSAEventSelect 模型基本相同。真正不同的地方，在于对CPU 的占用。完成端口模型只占用了60% 的CPU ，但是在维持同样规模的连接量时，另外两种模型（基于事件通知的重叠I/O 模型和WSAEventSelect 模型）占用更多的CPU 。完成端口的另外一个明显的优势是，它维持更大的吞吐量。

对以上各种模型进行分析后，可以会发现客户端与服务器数据通信机制本身存在的缺陷是一个瓶颈。在以上测试中，服务器被设计成只做简单的回应，即只是将客户端发送过来的数据发送回去。客户端（即使有比特率限制）不停的发送数据给服务器，这导致大量数据阻塞在服务器上与这个客户端对应的套接字上（无论是TCP 缓冲区还是AFD 的单套接字缓冲区，它们都是在非分页池上）。在最后三种性能比较好的模型中，同一时间只能执行一个接受输入操作，这意味着在大多数时间，还是有很多数据处于“ 未决” 状态。可以修改服务器程序使其以异步方式接受数据，这样一旦有数据达到，需要将数据缓存起来。这种方案的缺点是，当一个客户连续发送数据时，异步接受到了大量的数据。这会导致其他的客户无法接入，因为调用线程和工作者线程都不能处理其他的事件或完成通知。通常情况下，调用非阻塞异步接收函数，先返回WSAEWOULDBLOCK ，然后数据间断性的传输，而不采取连续接收的方式。

从以上测试结果，可以看出WSAEventSelect 模型和重叠I/O 模型是性能表现最佳的。两种基于事件通知的模型中，创建线程池来等待事件完成通知并作后续处理是很繁琐的，但是并不影响以它们来架构中型服务器的良好性能。当线程的数量随着客户端连接数量而逐增时，CPU 将花费大量时间在线程的上下文切换上，这将影响服务器的伸缩性，因为连接量达到一定数量后，便饱和了。完成端口模型提供了最佳的可扩展性，因为CPU 使用率低，其支持的客户连接量相对其他模型最多。

I/O 模型的选择

通过上一节对各种模型的测试分析，对于如何挑选最适合自己应用程序的I/O 模型已经很明晰了。同开发一个简单的运行多线程的锁定模式应用相比，其他每种I/O 模型都需要更为复杂的编程工作。因此，针对客户机和服务器应用开发模型的选择，有以下原则。

1. 客户端

若打算开发一个客户机应用，令其同时管理一个或多个套接字，那么建议采用重叠I/O 或WSAEventSelect 模型，以便在一定程度上提升性能。然而，假如开发的是一个以Windows 为基础的应用程序，要进行窗口消息的管理，那么WSAAsyncSelect 模型恐怕是一种最好的选择，因为WSAAsyncSelect 本身便是从Windows 消息模型借鉴来的。采用这种模型，程序需具备消息处理功能。

2. 服务器端

若开发的是一个服务器应用，要在一个给定的时间，同时控制多个套接字，建议采用重叠I/O 模型，这同样是从性能角度考虑的。但是，如果服务器在任何给定的时间，都会为大量I/O 请求提供服务，便应考虑使用I/O 完成端口模型，从而获得更佳的性能。

说明：

本文主要译自《 Network programming for microsoft windows 》一书的6.4 节《服务器策略》。

本文链接

关于windows ddk的一些问题

2010-02-02T02:35:00Z

一、DDK安装问题相信很多新手学习驱动开发的时候，DDK安装不好一切都免谈。我在自己的博客 http://hi.baidu.com/anglecloudy/blog/item/9b8d841636c6b84321a4e901.html 里面专门介绍了一下武安河winxp 2000 wdm开发的环境配置。完全可以装我那篇文章里面的软件XP 2600 DDK和Driver Studio 3.2(当...