十年编程经验分享

 经验分享，如何写线程 

写线程我想每人不会吧，我只是谈谈我自己的经验 
首先一定不要使用beginthread，其次最好也不使用CreateThread，看MSDN讲最好用_beginthread或者_beginthreadex 
写线程函数，我个人的经验是把线程函数写在类里，而且写出protected成员函数，而不是写成一个单独的函数，原因是： 
1。线程函数一般都是和类有关系 
2。写成类的函数，这样在线程函数里就可以调用类的成员变量。如果写成一个单独的函数，就不能直接调用类的私有成员变量了 
3。写成protected成员函数，可以供继承类调用 

另外我想大家写线程的参数传递方法都差不多，就是把类的指针传进去 
有时候我们需要传递其他的值，这时候我习惯是在cpp文件中定义一个全局的类指针，在线程函数里直接使用

经验分享，如何写DLL 

DLL一般有2种写法。 
第一种用MS.NET的向导帮助就能生产一个DLL，很简单。也就是有个类的头文件，写好DLL后把DLL和头文件给调用端一起使用。 
第二种是写一个接口文件。 

在这里，我介绍一下通过接口文件写DLL。接口文件主要就是用到纯虚类。（我以前明白什么是纯虚类，但就是不知道怎么用。也看过关于接口的介绍，但没有看到实际的例子） 
MSDN关于DLL也提到一句话，就是通过接口来写，但具体怎么写就没说了。 

我们需要一个接口文件（h文件），一个实现接口的类的文件（h和cpp文件或者只有h文件） 
接口文件名一般用“I”开头，实现接口的类的文件一般用Impl结尾。例如： 

//---------------------接口文件 IMyDLL.h －－－－－－ 
//---------------------接口文件 IMyDLL.h －－－－－－ 
struct IMyDLL 
{ 
  virtual void Init() = 0; 
} 

//-------------------实现文件 MyDLLImpl.h -------- 
//继承IMyDLL 
#include "IMyDLL.h" 

class CMyDLLImpl : public IMyDLL 
{ 
  virtual void Init(); 
} 

//-----------------实现文件 MyDLLImpl.cpp -------- 
#include "MyDLLImpl.h" 

void CMyDLLImpl::Init() 
{ 
  ;  //真正实现的代码 
} 

现在剩下的事情就是写DLL文件了 
//-------------DLL文件 MyDLL.h --------------- 
#ifdef MYDLL_EXPORTS 
#define MYDLL_API __declspec(dllexport) 
#else 
#define MYDLL_API __declspec(dllimport) 
#endif 

MYDLL_API void * CreateIMyDLL(); 

//------------DLL文件 MyDLL.cpp -------------- 
#include "MyDLL.h" 
#include "MyDLLImpl.h" 

BOOL APIENTRY DllMain( HANDLE hModule, 
                      DWORD  ul_reason_for_call, 
                      LPVOID lpReserved 
) 
{ 
    return TRUE; 
} 

MYDLL_API void * CreateIMyDLL() 
{ 
  CMyDLLImpl * pMyDLLImpl = new CMyDLLImpl(); 

  return static_cast <void *> (pMyDLLImpl); 
} 

 

这样基本上就写完了。调用端使用的时候只要DLL的头文件（MyDLL.h），库文件和接口文件（IMyDLL.h） 

为什么要使用接口写DLL，一个原因也就是MSDN说的在某些时候如果你给调用端一个类的头文件，可能这个头文件需要include很多其他的文件，对调用端并不合适。 
我自己也碰到过类似的问题，调用端不能编译，后来改成接口文件就好了。 
使用接口文件，就没有其他的什么文件。另外一个原因就是接口设计自身的好处了，这里就不说了。 

还要记得在接口文件中定义一个Release函数。供调用端释放内存 
Release函数很简单，就是写 
delete this;

经验分享，如何使用try,catch, throw之一 

try,catch, throw的含义就很清楚，但怎么使用，我还是过了好多年才明白一些 

先看一个不好的例子 

       
         



        
          
 
            
            
           //----------------- 不好的代码 -----------------  
           
 
            //----------------- 不好的代码 ----------------- 
 class CTest1; 
 class CTest2; 
 class CTest3; 
 
 void BadCode() 
 { 
   //new test1 
   CTest1 * pTest1 = new CTest1; 
 
   //do something 
   bool bRet = DoSomething(); 
   if (!bRet) 
   { 
     delete pTest1; 
     return; 
   } 
 
   //new CTest2 
   CTest2 * pTest2 = new CTest2; 
 
   //do something 
   bRet = DoSomething(); 
   if (!bRet) 
   { 
     delete pTest1; 
     delete pTest2; 
     return; 
   } 
 
   //new CTest3 
   CTest3 * pTest3 = new CTest3; 
 
   //do something 
   bRet = DoSomething(); 
   if (!bRet) 
   { 
     delete pTest1; 
     delete pTest2; 
     delete pTest3; 
     return; 
   } 
 
   //release 
   delete pTest1; 
   delete pTest2; 
   delete pTest3; 
 } 
  
          


       
         

下面是我个人比较喜欢的写法 

       
         



        
          
 
            
            
           //--------- 好的例子 ---------------  
           
 
            //--------- 好的例子 --------------- 
 class CTest1; 
 class CTest2; 
 class CTest3; 
 
 void MyCode() 
 { 
   //define 
   CTest1 * pTest1 = NULL; 
   CTest2 * pTest2 = NULL; 
   CTest3 * pTest3 = NULL; 
 
   //使用try, catch, throw 
   try 
   { 
     //new test1 
     pTest1 = new CTest1; 
 
     //do something 
     bool bRet = DoSomething(); 
     if (!bRet) 
       throw -1; 
 
     //new CTest2 
     pTest2 = new CTest2; 
 
     //do something 
     bRet = DoSomething(); 
     if (!bRet) 
       throw -2; 
 
     //new CTest3 
     pTest3 = new CTest3; 
 
     bRet = DoSomething(); 
     //do something 
     if (!bRet) 
       throw -3; 
 
     //release 
     delete pTest1; 
     pTest1 = NULL; 
     delete pTest2; 
     pTest2 = NULL; 
     delete pTest3; 
     pTest3 = NULL; 
   } 
   catch() 
   { 
     if (pTest1) 
       delete pTest1; 
     if (pTest2) 
       delete pTest2; 
     if (pTest3) 
       delete pTest3; 
   } 
 }
 
 另外在一个函数里不仅仅只有一个try，catch。可以有多个。比如： 
 //--------- 多个try的例子 --------------- 
 class CTest1; 
 class CTest2; 
 class CTest3; 
 
 void MyCode() 
 { 
   //define 
   CTest1 * pTest1 = NULL; 
   CTest2 * pTest2 = NULL; 
   CTest3 * pTest3 = NULL; 
 
   //使用try, catch, throw 
   try 
   { 
     //new test1 
     pTest1 = new CTest1; 
 
     //do something 
     bool bRet = DoSomething(); 
     if (!bRet) 
       throw -1; 
   } 
   catch() 
   { 
     ; 
   } 
   if (pTest1) 
     delete pTest1; 
 
   try 
   { 
     //new CTest2 
     pTest2 = new CTest2; 
 
     //do something 
     bRet = DoSomething(); 
     if (!bRet) 
       throw -2; 
   } 
   catch() 
   { 
     ; 
   } 
   if (pTest2) 
     delete pTest2; 
 
   try 
   { 
     //new CTest3 
     pTest3 = new CTest3; 
 
     bRet = DoSomething(); 
     //do something 
     if (!bRet) 
       throw -3; 
 
   } 
   catch() 
   { 
     ; 
   } 
   if (pTest3) 
     delete pTest3; 
 }
  
          


       
         

简单说一下 
第一种写法，需要在不同的地方delete 不同的变量 
第二种写法，在catch里delete所有的变量，代码的结构看起来更容易读，也易于维护 

//define 
  CTest1 * pTest1 = NULL; 
  CTest2 * pTest2 = NULL; 
  CTest3 * pTest3 = NULL; 
变量定义一定要在try之前定义，否则catch里找不到这些变量的定义 

另外很重要的一点，在delete之后必须将变量设成NULL 

catch里的delete可以删掉 
把try里的delete放catch后，因为指针都初始化NULL了 

经验分享，如何使用try,catch, throw之二 

什么时候使用try，catch，什么时候不用；什么时候用throw，什么时候不用。工作了很多年才明白。 

我个人的理解是： 
1。在private或者protected的成员函数不使用try，catch，而只使用throw 
2。如果在private或者protected的成员函数需要使用try，catch，那么就要使用rethrow 
3。在public成员函数里使用try，catch 
4。如果该类相对于整个项目来说是属于被调用层，那么public成员函数也可以不使用try，catch 
5。如果调用第三方的代码，我一般都会用try，catch 

我个人的习惯是把private或者protected成员函数的名字使用前缀__，public函数不用 

先看一个我不喜欢的写法 

       
         



        
          
 
            
            
           //------------- try, catch, throw 例子，不喜欢的写法 ------------  
           
 
            //------------- try, catch, throw 例子，不喜欢的写法 ------------ 
 class CTest 
 { 
 public: 
   int Init(); 
 private: 
   int __InitA(); 
   int __InitB(); 
   int __InitC(); 
 } 
 
 //--------- Init ------------ 
 int CTest:Init() 
 { 
   try 
   { 
     int err; 
     err = __InitA(); 
     if (err != 1) 
         throw -1; 
 
     err = __InitB(); 
     if (err != 1) 
         throw -2; 
 
     err = __InitC(); 
     if (err != 1) 
         throw 3; 
 
     return 1; 
   } 
   catch(int & err) 
   { 
     return err; 
   } 
 } 
 
 //---------- __InitA ---------- 
 int CTest::__InitA() 
 { 
   try 
   { 
     int err; 
     err = DoSomething1(); 
     if (err != 1) 
         throw -1; 
 
     err = DoSomething2(); 
     if (err != 1) 
         throw -2; 
       
     return 1; 
   } 
   catch(int & err) 
   { 
     return err; 
   } 
 } 
 
 __InitB, ___InitC和___InitA类似
 
 
 
 下面是我个人比较喜欢的写法 
 C/C++ code
 
 //------------- try, catch, throw 例子，喜欢的写法 ------------ 
 class CTest 
 { 
 public: 
   int Init(); 
 private: 
   int __InitA(); 
   int __InitB(); 
   int __InitC(); 
 } 
 
 //--------- Init ------------ 
 int CTest:Init() 
 { 
   try 
   { 
     __InitA(); 
     __InitB(); 
     __InitC(); 
 
     return 1; 
   } 
   catch(int & err) 
   { 
     return err; 
   } 
 } 
 
 //---------- __InitA ---------- 
 int CTest::__InitA() 
 { 
     int err; 
     err = DoSomething1(); 
     if (err != 1) 
         throw -1; 
 
     err = DoSomething2(); 
     if (err != 1) 
         throw -2; 
       
     return 1; 
 } 
 
 __InitB, ___InitC和___InitA类似
  
          


       
         

我喜欢的写法是private或者protected函数没有try，catch，只有throw 
在public函数就不需要去判断每个private或者protected函数的返回值了 
看起来会更清楚一点 

如果在private或者protected的成员函数需要使用try，catch，那么就要再throw，而不是调用return 

回想一下windows的win32函数,返回有2种方式 
一种是返回一个错误值 
另外一种就是抛出异常 
在我自己的设计中,什么时候返回值什么时候抛出异常,很值得推敲一下 

另外，仔细考虑一下private和protected函数，它们永远都会返回1或者在它们出错的时候就会throw，那在写函数声明的时候也就不需要返回值了，就返回void就可以了，也就不需要写return语句了。

然后，在某些情况下，有时候我们真的需要private或者protected函数返回错误代码，而不是throw，这个时候如果再声明函数的时候有返回值，就可以和没有返回值的函数区别开了。

经验分享，代码编写习惯 

以下是我个人的习惯： 
1。将所有的错误代码返回值写在一个文件里，使用define来定义错误代码 
2。写几const来定义操作错误代码，比如： 
typedef int MY_ERR; 
const int  MY_UNKNOW_ERR 0 
const int  MY_OK 1 
#define MY_SUCCEEDED(Status) ((MY_ERR)(Status) == MY_OK) 
#define MY_FAILED(Status) ((MY_ERR)(Status) != MY_OK) 
3。函数的返回值基本上都是MY_ERR，或者是void，很少有BOOL。因为很多情况下我们需要知道函数错在哪里，错误代码是什么。 
函数返回值是MY_ERR，而不是int。这样表示函数返回的是一个错误代码。如果函数返回int，那就表示函数的确是返回一个int的数值 
4。如何写类函数，请参考我的帖子"经验分享，如何使用try,catch, throw之二" 
5。基本上调用public函数的写法是： 
  MY_ERR err = myclass.test1(); 
  if MY_FAILED(err) 
      throw err; 
6。写一个错误消息映射文件，即每个错误代码映射一窜字符。字符可以是多语言的。一般写在xml文件里。这样根据每个函数的返回值，就可以得到映射的字符串。 
7。另外会有一个专门写日志的文件，日志文件有两种，一个是给用户看的操作日志，一个是给自己看的调试日志 
8。尽量不用在底层的代码里写MessageBox这样的函数。一个项目在哪里弹出对话框，大多少情况下都是由GUI来决定的，不是由底层的代码来决定的。 
9。提供一个common或者叫public的类，提供所有项目都可以使用的函数或者类 
10。另外就是总所周知的事情，使用N层系统去做代码设计 

日志有两种，一种是操作日志，一种是调试日志 
操作日志是记录用户每一步的操作情况，也不一定要写的很详细，也不一定要记录每一步 
调试日志是你认为需要记录的内容，比如一些变量的值。 
调试日志你可以写个工具实时查看，这样有一个好处，可以实时调试程序， 
在一些情况下，我们不能用.NET的调试工具，我们需要实时运行程序，不能用断点中断调试，这时候用调试日志就很有用。 
比如在调试线程的时候，有时候使用断点是不能得到正确结果的。 
我个人的习惯是调试信息写成“【类名】【方法名】调试信息” 

另外对于错误的信息，不仅要写到日志里，还要考虑是否弹出对话框给用户 

错误代码的使用 

先看一个不好的例子 
先看一个不好的例子 
C/C++ code
//------ 不好的例子 ------- 
void Test() 
{ 
  if (xxx1) 
  { 
      MessageBox(xxx); 
      return; 
  } 
  if (xxx2) 
  { 
      MessageBox(xxx); 
      return; 
  } 
  if (xxx3) 
  { 
      MessageBox(xxx); 
      return; 
  } 
} 
我个人喜欢的写法是: 
void Test() 
{ 
  try 
  { 
    if (xxx1) 
      throw ERROR_CODE_1; 
    if (xxx2) 
      throw ERROR_CODE_2; 
    if (xxx3) 
      throw ERROR_CODE_3; 
  } 
  catch(ERROR_CODE & err) 
  { 
      TCHAR * tchMsg = GetMessage(err); 
      MessageBox(tchMes); 
  } 
} 

 

提供一个函数,通过error code得到错误信息 

我在写下位机程序，并且下位机内存有限，个人认为要尽量使用#define，不知道对不对。 

我在写下位机程序时就碰到内存不够的问题，将const改成#define就好了 

另外在使用enum定义错误代码的时候，有时候需要从enum转换到int，自己感觉有点麻烦 
所以自己也就使用宏定义了，不过是一定要小心使用

线程函数写成类的protected函数

如果这个函数不是属于类的，那么就不能访问类的私有成员变量 
现在的前提是这个函数是类的函数，它就可以访问类的所有成员变量 

换一个角度，你先设计好了一个类，后来发现这个类的其中一个方法在线程下运行更合适，这个时候就把这个函数设计成线程调用的函数 
并且，这个函数仍然是类的一个成员函数，你不能因为它在线程下运行更合适，就更改你的类的设计 

线程是操作系统的概念，不是类的概念

经验分享，C语言代码编写习惯 

C++可以利用try, catch, throw来写代码风格 
C语言没有, 我个人使用goto语句来写代码风格 

大家都知道最好不要使用goto, 但不是完全不要使用goto语句 
函数设计有一个原则, 就是一个函数只有一个出口, 也就是只有一个地方有return 

Code
先看一个不好的例子 
C/C++ code
//--------- 不好的例子 ----------
boolean fun1()
{
  if (__funx1() != 0)
    return false;
  if (__funx2() != 0)
    return false;
  if (__funx3() != 0)
    return false;
  return true;
}
以下是我个人喜欢的风格 
//--------- 我个人喜欢的风格 ---------- 
//定义一个全局变量 
int g_nErrorCode = 0; 
//在函数__funx1, __funx2, __funx3中如果出错, 会设置g_nErrorCode值 
//这个函数会有两个出口, 一个return true; 一个return false; 
boolean fun1() 
{ 
  if (__funx1() != 0) 
    goto error; 
  if (__funx2() != 0) 
    goto error; 
  if (__funx3() != 0) 
    goto error; 
  return true; 
error: 
  return false; 
} 
//如果要这个函数只有一个出口, 可以按以下的代码去写 
boolean fun1() 
{ 
  bool bRet = true; 
  if (__funx1() != 0) 
    goto error; 
  if (__funx2() != 0) 
    goto error; 
  if (__funx3() != 0) 
    goto error; 
  //这句话永远都不能成立, 只有goto语句能进入 
  if (false) 
{ 
error: 
  bRet = false; 
} 
  return bRet; 
} 

经验分享，串口的通讯结构代码 

我在工作中写过串口调用的代码,我想我写的代码应该还算是比较规范,可以给大家做一个参考 
在代码中会用到一个叫SAMA.dll的文件, 关于它的源代码可以去下载,下载地址是 
http://d.download.csdn.net/down/1150752/zyx040404 

我写的这个串口封装调用是用在探针台的自动上下片系统里, 串口的封装代码在SAMA里, 此串口的通讯代码的结构是: 
ILoader.h接口文件, 定义了上位机和下位机发送命令的函数等等 
LoaderImpl.h, LoaderImpl.cpp 继承了ILoader.h文件, 是实现体 
LoaderMCUDataDefine.h定义了上下位机共同使用的数据结构和命令格式代码以及错误代码,上下位机的命令格式是第一个字节是0xFF,第二和第三个是重复的命令字节,这样可以避免收到错误的串口数据 
LoaderDataDefine.h定义了上位机的一些数据结构和消息定义,这些消息将发送给主窗口,由主窗口做相应的处理 

我现在写上部分代码 

       
         

        
           
           
 
             
             
            Code 
            
 
             //ILoader.h 
 C/C++ code
 
 #pragma once
 
 #include "../SAMA/SAMADataDefine.h"
 #include "LoaderDataDefine.h"
 #include "LoaderErrorCode.h"
 
 struct ILoader 
 {
     //relese
     virtual inline void Release() = 0;
 
     //Initialize
     virtual COMMON_ERR Initialize(const TCHAR * tchConfigFile) = 0;
 
     //送消息的窗口句柄
     virtual inline void SetNotifyWindow(HWND hWnd) = 0;
 
     //send command to low machine
     virtual inline COMMON_ERR SendCommandToLowMachineEx(BYTE iCommand, int iValue, BOOL bDirection) = 0;
 
     //send other command to low machine
     virtual inline COMMON_ERR SendCommandToLowMachine(BYTE iCommand, DWORD dwWaitTime = LOADER_MIN_WAIT_LOW_MACHINE_RETURN_TIME, BOOL bIsForcedSend = FALSE, BOOL bWaitResult = FALSE) = 0;
 
     //set comm infromation
     virtual inline COMMON_ERR SetCommInformation() = 0;
 
     //update low machine para
     virtual inline COMMON_ERR GetLowMachinePara() = 0;
     virtual inline COMMON_ERR UpdateLowMachinePara(const tagLoaderPara & stuLoaderPara) = 0;
 
 virtual inline BOOL IsWorking() const = 0;
     virtual inline BOOL IsWarning() const = 0;
     virtual inline int GetErrorCode() const = 0;
     virtual inline int GetErrorValue() const = 0;
     virtual inline COMMON_ERR IsValid() const = 0;
 
 };
  
           
 
       
         


       
         

        
           
           
 
             
             
            //LoaderImpl.h  
            
 
             //LoaderImpl.h 
 
 #pragma once
 
 #include "ILoader.h"
 #include "../SAMA/comm/CComm.h"
 
 class CLoaderImpl : public ILoader, public CAsynThreadComm
 {
 public:
     CLoaderImpl(void);
     virtual ~CLoaderImpl(void);
 
     //relese
     virtual inline void Release();
 
     //Initialize
     virtual COMMON_ERR Initialize(const TCHAR * tchConfigFile);
 
     //送消息的窗口句柄
     virtual inline void SetNotifyWindow(HWND hWnd);
 
     //send command to low machine
     virtual inline COMMON_ERR SendCommandToLowMachineEx(BYTE iCommand, int iValue, BOOL bDirection);
 
     //send command to low machine
     virtual inline COMMON_ERR SendCommandToLowMachine(BYTE iCommand, DWORD dwWaitTime = LOADER_MIN_WAIT_LOW_MACHINE_RETURN_TIME, BOOL bIsForcedSend = FALSE, BOOL bWaitResult = FALSE);
 
     //set comm information
     virtual inline COMMON_ERR SetCommInformation();
 
     //update low machine para
     virtual inline COMMON_ERR GetLowMachinePara();
     virtual inline COMMON_ERR UpdateLowMachinePara(const tagLoaderPara & stuLoaderPara);
 
     virtual inline BOOL IsWorking() const;
     virtual inline BOOL IsWarning() const;
     virtual inline int GetErrorCode() const;
     virtual inline int GetErrorValue() const;
     virtual inline COMMON_ERR IsValid() const;
 
 
 private:
     HANDLE                    m_hWaitResult;
 
     BOOL                    m_bIsWorking;                        //是否正在工作
     BOOL                    m_bIsWarning;                        //是否正在报警
     int                        m_nErrorCode;
     int                        m_nErrorValue;
 
     tagLoaderPara            m_stuLoaderPara;
 
     inline COMMON_ERR        __SendCommandToLowMachineOnForce(BYTE iCommand, DWORD dwWaitTime = LOADER_MIN_WAIT_LOW_MACHINE_RETURN_TIME, BOOL bWaitResult = FALSE);
 
 protected:
     virtual void            __OnReceive();
 
 };
  
           
 
       
         


       
         

        
           
           
 
             
             
            //LoaderImpl.cpp  
            
 
             //LoaderImpl.cpp 
 
 #include "StdAfx.h"
 #include ".\Loaderimpl.h"
 #include "../SAMA/SAMA.h"
 #include "LogDefine.h"
 #include "../SAMA/SAMAXML/IXMLParser.h"
 #include <process.h>
 #include <math.h>
 
 static CLoaderImpl *    l_pLoader = NULL;
 
 //------------------------------------------------------------------------------------------------------
 //                                                CLoaderImpl
 //------------------------------------------------------------------------------------------------------
 CLoaderImpl::CLoaderImpl(void)
 {
     m_hWaitResult                    = CreateEvent(NULL, FALSE, FALSE, NULL);
 
     m_bIsWorking                    = FALSE;
     m_bIsWarning                    = FALSE;
     m_nErrorCode                    = LOADER_ERROR_NO_ERROR;
     m_nErrorValue                    = 0;
 
     memset(&m_stuLoaderPara, NULL, sizeof(m_stuLoaderPara));
 }
 
 //------------------------------------------------------------------------------------------------------
 //                                                ~CLoaderImpl
 //------------------------------------------------------------------------------------------------------
 CLoaderImpl::~CLoaderImpl(void)
 {
     CloseHandle(m_hWaitResult);
 }
 
 //------------------------------------------------------------------------------------------------------
 //                                                Release
 //------------------------------------------------------------------------------------------------------
 inline void CLoaderImpl::Release()
 {
     delete this;
 }
 
 //------------------------------------------------------------------------------------------------------
 //                                                __OnReceive
 //------------------------------------------------------------------------------------------------------
 void CLoaderImpl::__OnReceive()
 {
     static BYTE    byteAryMsg[MCU_SEND_BUFFER_SIZE];
     memset(byteAryMsg, NULL, sizeof(byteAryMsg));
 
     //business process
     COMMON_ERR err = COMMON_OK; 
     size_t    iLen = 0;
 
     BOOL    bIsWorking = FALSE;
     try
     {
         //read comm
         iLen = Read((char *) byteAryMsg, 1);
         if (0 == iLen)
             throw ERROR_LOADER_CAN_NOT_READ_SERIEAL_DATA;
 
         if (byteAryMsg[0] != LOADER_H2L_ACTION)
             throw ERROR_LOADER_IT_IS_NOT_ACTION;
 
         //read receive command
         iLen = Read((char *) byteAryMsg, 2);
         if (byteAryMsg[0] != byteAryMsg[1])
             throw ERROR_LOADER_IT_IS_NOT_COMMAND;
     }
     catch ()
     {
         //LOADER_LOG_DEBUG3(_T("[__OnReceive] error code: %d, byteAryMsg[0]: %d, byteAryMsg[1]: %d"), err, byteAryMsg[0], byteAryMsg[1]);
         return;
     }
 
     LOADER_LOG_INFO1(_T("收到：%d"), byteAryMsg[0]);
 
     try
     {
         switch(byteAryMsg[0])
         {
         case LOADER_H2L_GET_ERROR_CODE:
             iLen = Readex((char *) byteAryMsg, 6);
             m_nErrorCode = byteAryMsg[0];
             m_nErrorValue = byteAryMsg[1];
 
             LOADER_LOG_INFO1(_T("错误: %d"), m_nErrorCode);
 
             //need set it now before post message, 
             //or caller will receive message first, and get working status later, it's wrong
             m_bIsWorking = FALSE;
 
             if (m_nErrorCode != LOADER_ERROR_NO_ERROR)
             {
                 m_bIsWarning = TRUE;
                 if (m_hNotifyWindow)
                     PostMessage(m_hNotifyWindow, WM_LOADER_WARNING, (WPARAM) m_nErrorCode, NULL);
             }
 
             break;
         case LOADER_H2L_UPDATE_PARA:
             //m_bIsGetLowMachinePara = TRUE;
 
             //send result
             if (m_hNotifyWindow)
                 PostMessage(m_hNotifyWindow, WM_LOADER_UPDATE_PARA, NULL, NULL);
 
             break;
         case LOADER_H2L_GET_PARA:
             //read data number
             iLen = Readex((char *) byteAryMsg, 2);
 
             {
                 //read data
                 int i = byteAryMsg[0] * 256 + byteAryMsg[1];
                 iLen = Readex((char *) byteAryMsg, i);
 
                 i = 0;
 
                 m_stuLoaderPara.nWaitVacuumTime = byteAryMsg[i] * 256 + byteAryMsg[i + 1];
                 i = i + 2;
             }
 
             //need set it now before post message, 
             //or caller will receive message first, and get working status later, it's wrong
             m_bIsWorking = FALSE;
 
             //send result
             if (m_hNotifyWindow)
                 PostMessage(m_hNotifyWindow, WM_LOADER_GET_PARA, (WPARAM) &m_stuLoaderPara, NULL);
 
         default:
 
             break;
         }
     }
     catch ()
     {
         LOADER_LOG_DEBUG1(_T("[__OnReceive] unknow error: %d"), GetLastError());
     }
 
     m_bIsWorking = bIsWorking;
 
     ClearReceiveBuffer();
 
     SetEvent(m_hWaitResult);
  
           
 
       
         


       
         

        
           
           
 
             
             
            //接着LoaderImpl.cpp  
            
 
             //接着LoaderImpl.cpp 
 
 //------------------------------------------------------------------------------------------------------
 //                                                Initialize
 //------------------------------------------------------------------------------------------------------
 COMMON_ERR CLoaderImpl::Initialize(const TCHAR * tchConfigFile)
 {
     LOADER_LOG_INFO(_T("上下片系统初始化"));
 
     l_pLoader = this;
 
     try
     {
         if (g_pILogger)
             g_pILogger->SetLogWindowName(_T("Loader Log"));
 
         //init comm port
         SetThreadPriority(THREAD_PRIORITY_NORMAL);
         //if (!Open(m_stuLoaderSerial.nPort, m_stuLoaderSerial.nBaudRate))
         //    throw ERROR_LOADER_CAN_NOT_OPEN_COMM_PORT;
 
         LOADER_LOG_DEBUG(_T("[Initialize] 自动上下片初始化成功"));
 
         return COMMON_OK;
     }
     catch (COMMON_ERR & err)
     {
         LOADER_LOG_DEBUG1(_T("[Initialize] error code is : %d"), err);
 
         throw err;
     }
 }
 
 //------------------------------------------------------------------------------------------------------
 //                                                SendCommandToLowMachineEx
 //------------------------------------------------------------------------------------------------------
 COMMON_ERR CLoaderImpl::SendCommandToLowMachineEx(BYTE iCommand, int iValue, BOOL bDirection)
 {
     COMMON_ERR err = IsValid();
     if COMMON_FAILED(err)
         return err;
 
     LOADER_LOG_INFO1(_T("发送：%d"), iCommand);
 
     BYTE byteAryMsg[12] = {0};
     byteAryMsg[0] = LOADER_H2L_ACTION;
     byteAryMsg[1] = byteAryMsg[2] = iCommand;
     if (bDirection)
         byteAryMsg[3] = 1;
     else
         byteAryMsg[3] = 0;
     byteAryMsg[4] = int(iValue / 256);
     byteAryMsg[5] = iValue % 256;
     byteAryMsg[6] = 0;
     byteAryMsg[7] = 0;
     byteAryMsg[8] = byteAryMsg[3] ^ byteAryMsg[4] ^ byteAryMsg[5] ^ byteAryMsg[6] ^ byteAryMsg[7];
     byteAryMsg[9] = byteAryMsg[10] = byteAryMsg[11] = LOADER_H2L_END;
 
     Write((char *) byteAryMsg, 12);
 
     return COMMON_OK;
 }
 
 //------------------------------------------------------------------------------------------------------
 //                                                __SendCommandToLowMachineOnForce
 //------------------------------------------------------------------------------------------------------
 COMMON_ERR CLoaderImpl::__SendCommandToLowMachineOnForce(BYTE iCommand, DWORD dwWaitTime, BOOL bWaitResult)
 {
     return SendCommandToLowMachine(iCommand, dwWaitTime, TRUE, bWaitResult);
 }
 
 //------------------------------------------------------------------------------------------------------
 //                                                SendCommandToLowMachine
 //------------------------------------------------------------------------------------------------------
 COMMON_ERR CLoaderImpl::SendCommandToLowMachine(BYTE iCommand, DWORD dwWaitTime, BOOL bIsForcedSend, BOOL bWaitResult)
 {
     if (!bIsForcedSend)
     {
         COMMON_ERR err = IsValid();
         if COMMON_FAILED(err)
             return err;
     }
 
     if (bWaitResult)
         ResetEvent(m_hWaitResult);
 
     m_bIsWorking = TRUE;
 
     LOADER_LOG_INFO1(_T("发送：%d"), iCommand);
 
     BYTE byteAryMsg[6] = {0};
     byteAryMsg[0] = LOADER_H2L_ACTION;
     byteAryMsg[1] = byteAryMsg[2] = iCommand;
     byteAryMsg[3] = byteAryMsg[4] = byteAryMsg[5] = LOADER_H2L_END;
 
     Write((char *) byteAryMsg, 6);
 
     //wait
     if (bWaitResult)
     {
         DWORD dwRet = WaitForSingleObject(m_hWaitResult, dwWaitTime);
         if (WAIT_OBJECT_0 != dwRet)
         {
             m_nErrorCode = ERROR_LOADER_WAIT_OVER_TIME;
             return m_nErrorCode;
         }
     }
     else
         Sleep(dwWaitTime);
 
     return COMMON_OK;
 }
 
 //------------------------------------------------------------------------------------------------------
 //                                                GetErrorData
 //------------------------------------------------------------------------------------------------------
 COMMON_ERR CLoaderImpl::GetErrorData()
 {
     return __SendCommandToLowMachineOnForce(LOADER_H2L_GET_ERROR_CODE);
 }
 
 //------------------------------------------------------------------------------------------------------
 //                                                GetLowMachinePara
 //------------------------------------------------------------------------------------------------------
 COMMON_ERR CLoaderImpl::GetLowMachinePara()
 {
     return __SendCommandToLowMachineOnForce(LOADER_H2L_GET_PARA);
 }
 
 //------------------------------------------------------------------------------------------------------
 //                                                UpdateLowMachinePara
 //------------------------------------------------------------------------------------------------------
 COMMON_ERR CLoaderImpl::UpdateLowMachinePara(const tagLoaderPara & stuLoaderPara)
 {
     LOADER_LOG_INFO1(_T("发送：%d"), LOADER_H2L_UPDATE_PARA);
 
     //m_bIsGetLowMachinePara = FALSE;
 
     m_stuLoaderPara.nWaitVacuumTime = stuLoaderPara.nWaitVacuumTime;
 
     BYTE byteAryMsg[1000] = {0};
     byteAryMsg[0] = LOADER_H2L_ACTION;
     byteAryMsg[1] = byteAryMsg[2] = LOADER_H2L_UPDATE_PARA;
 
     int i = 3;
     byteAryMsg[i] = m_stuLoaderPara.nWaitVacuumTime / 256;
     byteAryMsg[i + 1] = m_stuLoaderPara.nWaitVacuumTime % 256;
     i = i + 2;
 
     byteAryMsg[i] = byteAryMsg[i + 1] = byteAryMsg[i + 2] = LOADER_H2L_END;
 
     Write((char *) byteAryMsg, i + 3);
 
     return COMMON_OK;
 }
 
 //------------------------------------------------------------------------------------------------------
 //                                                SetCommInformation
 //------------------------------------------------------------------------------------------------------
 COMMON_ERR CLoaderImpl::SetCommInformation()
 {
     ConfigDialog();
 
     return COMMON_OK;
 }
 
 //------------------------------------------------------------------------------------------------------
 //                                                IsWorking
 //------------------------------------------------------------------------------------------------------
 inline BOOL CLoaderImpl::IsWorking() const
 {
     return m_bIsWorking;
 }
 
 //------------------------------------------------------------------------------------------------------
 //                                                IsWarning
 //------------------------------------------------------------------------------------------------------
 inline BOOL CLoaderImpl::IsWarning() const
 {
     return m_bIsWarning;
 }
 
 //------------------------------------------------------------------------------------------------------
 //                                                GetErrorCode
 //------------------------------------------------------------------------------------------------------
 inline int CLoaderImpl::GetErrorCode() const
 {
     return m_nErrorCode;
 }
 
 //------------------------------------------------------------------------------------------------------
 //                                                GetErrorValue
 //------------------------------------------------------------------------------------------------------
 inline int CLoaderImpl::GetErrorValue() const
 {
     return m_nErrorValue;
 }
 
 //------------------------------------------------------------------------------------------------------
 //                                                IsValid
 //------------------------------------------------------------------------------------------------------
 inline COMMON_ERR CLoaderImpl::IsValid() const
 {
     COMMON_ERR err = COMMON_OK;
 
     if (m_bIsWorking)
     {
         LOADER_LOG_INFO(_T("正忙"));
         err = ERROR_LOADER_IS_WORKING;
     }
 
     if (m_bIsWarning)
     {
         LOADER_LOG_INFO(_T("报警"));
         err = GetErrorCode();
     }
 
     if COMMON_FAILED(err)
     {
         if (m_hNotifyWindow)
             PostMessage(m_hNotifyWindow, WM_LOADER_WARNING, (WPARAM) err, NULL);
     }
 
     return err;
 }
 
 //------------------------------------------------------------------------------------------------------
 //                                                SetNotifyWindow
 //------------------------------------------------------------------------------------------------------
 inline void CLoaderImpl::SetNotifyWindow(HWND hWnd)
 {
     m_hNotifyWindow = hWnd;
 }
  
           
 
       
         


       
         

        
           
           
 
             
             
            //LoaderMCUDataDefine.h  
            
 
             //LoaderMCUDataDefine.h 
 
 #ifndef LOADER_DATA_DEFINE_H
 #define LOADER_DATA_DEFINE_H
 
 struct tagLoaderPara
 {
     int            nWaitVacuumTime;                        //等待真空时间
 };
 
 //------------------------------------------------------------------------------------------------------
 //                        high machine to low machine command
 //------------------------------------------------------------------------------------------------------
 #define LOADER_H2L_END                                            255        //end
 
 //those commands need not para
 #define LOADER_H2L_ACTION                                        255        //action
 
 #define LOADER_H2L_GET_ERROR_CODE                                40        //get error code
 
 //those commands need para
 #define LOADER_H2L_UPDATE_PARA                                    206        //update para
 
 
 //------------------------------------------------------------------------------------------------------
 //                                            error code
 //------------------------------------------------------------------------------------------------------
 #define LOADER_ERROR_NO_ERROR                                    0        //没有错误
 #define LOADER_ERROR_UNKNOW_ERROR                                255        //未知错误
 
  
           
 
       
         


       
         

        
           
           
 
             
             
            //LoaderDataDefine.h  
            
 
             //LoaderDataDefine.h 
 
 #pragma once
 #include "../SAMA/SAMADataDefine.h"
 #include "../LoaderMCU/LoaderMCUDataDefine.h"
 
 #define ID_TAGNAME_LOADER_SERIAL                                        _T("串口")
 #define ID_TAGNAME_LOADER_SERIAL_PORT                                    _T("端口")
 #define ID_TAGNAME_LOADER_SERIAL_BAUD_RATE                                _T("波特率")
 
 //message
 #define WM_LOADER_WARNING                                                WM_USER + 800
 #define WM_LOADER_PARA_IS_NOT_RIGHT                                        WM_USER + 801
 #define WM_LOADER_GET_PARA                                                WM_USER + 807
 #define WM_LOADER_UPDATE_PARA                                            WM_USER + 814
 
 #define LOADER_DEFAULT_START_WAFER_INDEX                                -1
 #define LOADER_MAX_WAIT_LOW_MACHINE_RETURN_TIME                            60000    //20 seconds
 #define LOADER_MIN_WAIT_LOW_MACHINE_RETURN_TIME                            600        //0.2 seconds
  
           
 
       
         


       
         

        
           
           
 
             
             
            //还有一个是LoaderErrorCode.h  
            
 
             //还有一个是LoaderErrorCode.h 
 
 #pragma once
 
 //[1000-1990] Loader
 const int        ERROR_LOADER_CAN_NOT_OPEN_COMM_PORT                        = 1000;    //打开串口错误
 const int        ERROR_LOADER_INIT_FAILED                                = 1001;    //自动上下片初始化错误
 const int        ERROR_LOADER_IS_INVALED                                    = 1002;    //上下片不可用
 const int        ERROR_LOADER_IS_WORKING                                    = 1003;    //自动上下片正在工作
 const int        ERROR_LOADER_IS_WARNING                                    = 1004;    //自动上下片报警
 
 const int        ERROR_LOADER_WAIT_OVER_TIME                                = 1030;    //等待串口超时
 
 const int        ERROR_LOADER_CAN_NOT_READ_SERIEAL_DATA                    = 1032;    //没有读到串口数据
 const int        ERROR_LOADER_IT_IS_NOT_ACTION                            = 1033;    //不是下位机命令头
 const int        ERROR_LOADER_IT_IS_NOT_COMMAND                            = 1034;    //不是下位机命令
  
           
 
       
         


       
         

          
        该项目会生成一个dll文件,供主程序去调用 
       
         


       
         

          
        有关写日志的代码请参考SAMA，在我的资源里有下载
       
         


       
         

        
          http://download.csdn.net/source/1150752
       
         

解释一下 
SendCommandToLowMachine 
SendCommandToLowMachineEx是发送命令并且带一个参数 
__SendCommandToLowMachineOnForce是直接发送，不需要检查是否可以发送的状态，上面两个需要检查 
参数dwWaitTime是等待下位机回复的时间 
参数bIsForcedSend是否不需要检测状态直接发送 
参数bWaitResult是否需要等待下位机一定要回复信息，这里会有一个事件对象 
UpdateLowMachinePara是发送多个参数给下位机 

__OnReceive需要仔细看看，前面一段是判断是不是我们规定的命令格式，中间是命令的处理 
如果需要通知主窗口，还会发消息给主窗口

注意m_bIsWorking的付值时间和条件，其实目前的写法有错误