① 龔建偉《Visual C++/Turbo C串口通信編程實踐》電子書、源代碼、光碟內容 [email protected]
在指兆穗猜敬這兒唯卜，自己下載吧
http://ishare.iask.sina.com.cn/search.php?key=Visual+C%2B%2B%2FTurbo+C%B4%AE%BF%DA%CD%A8%D0%C5%B1%E0%B3%CC%CA%B5%BC%F9&format=
② 用visual C++怎樣編一個最簡單的串口程序
用VC++6.0實現PC機與單片機之間
串列通信的方法
湖南大學（長沙410082） 於小億 王 輝 張志學
摘 要 詳細介紹了在Windows環境下應用VC++實現PC機與單片機的幾種串列通信方法，給出了用Visual C++6.0編寫的PC機程序和用C51編寫的單片機通信程序。經實際應用系統運行穩定可靠。
關鍵詞 Visual C++ 類 串列通信
--------------------------------------------------------------------------------
工業控制領域（如DCS系統），經常涉及到串列通信問題。為了實現微機和單片機之間的數據交換，人們用各種不同方法實現串列通信，如DOS下採用匯編語言或C語言，但在Windows 環境下卻存在一些困難和不足。在Windows操作系統已經占據統治地位的情況下（何況有些系統根本不支持DOS如Windows2000）開發Windows 環境下串列通信技術就顯得日益重要。
VC++6.0是微軟公司於1998年推出的一種開發環境，以其強大的功能，友好的界面，32位面向對象的程序設計及Active X的靈活性而受廣大軟體開發者的青睞，被廣泛應用於各個領域。應用VC++開發串列通信目前通常有如下幾種方法：一是利用Windows API通信函數；二是利用VC的標准通信函數_inp、_inpw、_inpd、_outp、_outpw、_outpd等直接對串口進行操作；三是使用Microsoft Visual C++的通信控制項（MSComm）；四是利用第三方編寫的通信類。以上幾種方法中第一種使用面較廣，但由於比較復雜，專業化程度較高，使用較困難；第二種需要了解硬體電路結構原理；第三種方法看來較簡單，只需要對串口進行簡單配置，但是由於使用令人費解的VARIANT 類，使用也不是很容易；第四種方法是利用一種用於串列通信的CSerial類（這種類是由第三方提供），只要理解這種類的幾個成員函數，就能方便的使用。筆者利用CSerial類很方便地實現了在固定式EBM氣溶膠滅火系統分區啟動器（單片機系統）與上位機的通信。以下將結合實例，給出實現串列通信的幾種方法。
1 Windows API通信函數方法
與通信有關的Windows API函數共有26個，但主要有關的有：
CreateFile() 用 「comn」（n為串口號）作為文件名就可以打開串口。
ReadFile() 讀串口。
WriteFile() 寫串口。
CloseHandle() 關閉串口句柄。初始化時應注意CreateFile()函數中串口共享方式應設為0，串口為不可共享設備，其它與一般文件讀寫類似。以下給出API實現的源代碼。
2 利用埠函數直接操作
這種方式主要是採用兩個埠函數_inp(), _outp()實現對串口的讀寫，其中讀埠函數的原型為：
int _inp(unsigned shot port)
該函數從埠讀取一個位元組，埠號為0~65535。
寫埠的函數原型為：
int _outp(unsigned shot port, int databyte)
該函數向指定埠寫入一個位元組。
不同的計算機串口地址可能不一樣，通過向串口的控制及收發寄存器進行讀寫，可以實現靈活的串口通信功能，由於涉及具體的硬體電路討論比較復雜，在此不加贅述。
3 MSComm控制項
MSComm控制項是微軟開發的專用通信控制項，封裝了串口的所有功能，使用很方便，但在實際應用中要小心對其屬性進行配置。下面詳細說明該類應用方法。
3.1 MSComm控制項的屬性
CommPort：設置串口號，類型 short :1-comm1 2-comm2.
Settings：設置串口通信參數，類型 CString :B波特率，P奇偶性（N無校驗，E偶校驗，O奇校驗），D位元組有效位數，S停止位。
PortOpen：設置或返回串口狀態，類型 BOOL：TURE打開，FALSE關閉。
InputMode:設置從接收緩沖區讀取數據的格式，類型 long： 0-Text 1-Bin。
Input:從接收緩沖區讀取數據，類型 VARIANT。
InBufferCount:接收緩沖區中的位元組數，類型：short。
InBufferSize:接收緩沖區的大小，類型：short。
Output:向發送緩沖區寫入數據，類型：VARIANT。
OutBufferCount:發送緩沖區中的位元組數，類型：short。
OutBufferSize:發送緩沖區的大小，類型：short。
InputLen:設置或返回Input讀出的位元組數，類型：short。
CommEvent:串口事件，類型：short。
3.2 程序示例
串口初始化
if (!m_comm.GetPortOpen())
m_comm.SetPortOpen(TURE); /*打開串口*/
m_comm.SetSettings( "4800,n,8,1 "); /*串口參數設置*/
m_comm.SetInputMode(0); /*設置TEXT緩沖區輸入方式*/
m_comm.SetRthresHold(1); /*每接收一個字元則激發OnComm()事件*/
接收數據
m_comm.SetInputLen(1); /*每次讀取一個字元
VARINAT V1=m_comm.GetInput();
/*讀入字元*/
m_V1=V1.bstrval;
發送字元 m_comm.SetOutput(Colevariant ( "Hello "); /*發送 「Hello」 */
3.3 注意
SetOutput方法可以傳輸文本數據或二進制數據。用SetOutput方法傳輸文本數據，必須定義一個包含一個字元串的 Variant。發送二進制數據，必須傳遞一個包含位元組數組的Variant 到 Output 屬性。正常情況下，如果發送一個 ANSI 字元串到應用程序，可以以文本數據的形式發送。如果發送包含嵌入控制字元、Null 字元等的數據，要以二進制形式發送。此處望引起讀者注意，筆者曾經在此犯錯。
4 VC++類CSerial
4.1 串列通信類CSerial簡介
Cserial 是由MuMega Technologies公司提供的一個免費的VC++類，可方便地實現串列通信。以下為該類定義的說明部分。
class CSerial
{
public:
CSerial();
~CSerial();
BOOL Open( int nPort = 2, int nBaud = 9600 );
BOOL Close( void );
int ReadData( void *, int );
int SendData( const char *, int );
int ReadDataWaiting( void );
BOOL IsOpened( void ){ return( m_bOpened ); }
protected:
BOOL WriteCommByte( unsigned char );
HANDLE m_hIDComDev;
OVERLAPPED m_OverlappedRead, m_OverlappedWrite;
BOOL m_bOpened;
}
4.2 串列通信類Cserial 成員函數簡介
1. CSerial：：Cserial是類構造函數，不帶參數，負責初始化所有類成員變數。
2. CSerial:: Open這個成員函數打開通信埠。帶兩個參數,第一個是埠號，有效值是1到4，第二個參數是波特率，返回一個布爾量。
3. CSerial:: Close函數關閉通信埠。類析構函數調用這個函數，所以可不用顯式調用這個函數。
4. CSerial:: SendData函數把數據從一個緩沖區寫到串列埠。它所帶的第一個參數是緩沖區指針，其中包含要被發送的資料；這個函數返回已寫到埠的實際位元組數。
5. CSerial:: ReadDataWaiting函數返回等待在通信埠緩沖區中的數據，不帶參數。
6. CSerial:: ReadData函數從埠接收緩沖區讀入數據。第一個參數是void＊緩沖區指針，資料將被放入該緩沖區；第二個參數是個整數值，給出緩沖區的大小。
③ 《Visual+C++_Turbo+C串口通信編程實踐》與《Visual C++串口通信技術詳解》哪本內容好，望高手指點一下
我用的是《Visual+C++_Turbo+C串口通信編程實踐》，感覺還好，串口編程時遇到的問題基本都有。
④ 龔建偉《Visual C++/Turbo C串口通信編程實踐》電子書、源代碼、光碟內容。
我有。 發啦
樓主給分啊。
⑤ 《Visual C#.NET串口通信及測控應用典型實例》求此書電子版
網路網盤搜索一下就有的，要製作高清PDF可以私信。
⑥ 跪求 Visual C#.NET串口通信及測控應用典型實例 PDF 謝謝了 解決++++分
有一個文本的代碼《用C#serialport寫一個通信串口調試程序》，可惜你要PDF的。
⑦ vc++ 串口通訊
兩慎頃個核心文件LZ可以參考寬扮陸下
//SerialPort.h
#ifndef __SERIALPORT_H__
#define __SERIALPORT_H__
#define WM_COMM_BREAK_DETECTED WM_USER+1 // A break was detected on input.
#define WM_COMM_CTS_DETECTED WM_USER+2 // The CTS (clear-to-send) signal changed state.
#define WM_COMM_DSR_DETECTED WM_USER+3 // The DSR (data-set-ready) signal changed state.
#define WM_COMM_ERR_DETECTED WM_USER+4 // A line-status error occurred. Line-status errors are CE_FRAME, CE_OVERRUN, and CE_RXPARITY.
#define WM_COMM_RING_DETECTED WM_USER+5 // A ring indicator was detected.
#define WM_COMM_RLSD_DETECTED WM_USER+6 // The RLSD (receive-line-signal-detect) signal changed state.
#define WM_COMM_RXCHAR WM_USER+7 // A character was received and placed in the input buffer.
#define WM_COMM_RXFLAG_DETECTED WM_USER+8 // The event character was received and placed in the input buffer.
#define WM_COMM_TXEMPTY_DETECTED WM_USER+9 // The last character in the output buffer was sent.
#include <windows.h>
class CSerialPort
{
public:
int m_nWriteSize;
// contruction and destruction
CSerialPort();
virtual ~CSerialPort();
// port initialisation
BOOL InitPort(CWnd* pPortOwner, UINT portnr = 1, UINT baud = 19200, char parity = 'N', UINT databits = 8, UINT stopbits = 1, DWORD dwCommEvents = EV_RXCHAR, UINT writebuffersize = 1024);
HANDLE m_hComm;
// start/stop comm watching
BOOL StartMonitoring();
BOOL RestartMonitoring();
BOOL StopMonitoring();
//get the information from the port
DWORD GetWriteBufferSize();
DWORD GetCommEvents();
DCB GetDCB();
//缺宴write to the port
void WriteToPort(char* string);
void WriteToPort(char* string,int n);
void WriteToPort(LPCTSTR string);
void WriteToPort(LPCTSTR string,int n);
//close the port
void ClosePort();
protected:
// protected memberfunctions
void ProcessErrorMessage(char* ErrorText);
static UINT CommThread(LPVOID pParam);
static void ReceiveChar(CSerialPort* port, COMSTAT comstat);
static void WriteChar(CSerialPort* port);
// thread
CWinThread* m_Thread;
// synchronisation objects
CRITICAL_SECTION m_csCommunicationSync;
BOOL m_bThreadAlive;
// handles
HANDLE m_hWriteEvent;
HANDLE m_hShutdownEvent;
// Event array.
// One element is used for each event. There are two event handles for each port.
// A Write event and a receive character event which is located in the overlapped structure (m_ov.hEvent).
// There is a general shutdown when the port is closed.
HANDLE m_hEventArray[3];
// structures
OVERLAPPED m_ov;
COMMTIMEOUTS m_CommTimeouts;
DCB m_dcb;
// owner window
CWnd* m_pOwner;
// misc
UINT m_nPortNr;
char* m_szWriteBuffer;
char* m_szReadBuffer;
DWORD m_dwCommEvents;
DWORD m_nWriteBufferSize;
};
#endif __SERIALPORT_H__
//SerialPort.cpp
#include "stdafx.h"
#include "SerialPort.h"
#include <assert.h>
static BOOL RA = TRUE;
//
// Constructor
//
CSerialPort::CSerialPort()
{
m_hComm = NULL;
// initialize overlapped structure members to zero
m_ov.Offset = 0;
m_ov.OffsetHigh = 0;
// create events
m_ov.hEvent = NULL;
m_hWriteEvent = NULL;
m_hShutdownEvent = NULL;
m_szWriteBuffer = NULL;
m_nWriteSize=1;
m_bThreadAlive = FALSE;
}
//
// Delete dynamic memory
//
CSerialPort::~CSerialPort()
{
do
{
SetEvent(m_hShutdownEvent);
} while (m_bThreadAlive);
// if the port is still opened: close it
if (m_hComm != NULL)
{
CloseHandle(m_hComm);
m_hComm = NULL;
}
// Close Handles
if(m_hShutdownEvent!=NULL)
CloseHandle( m_hShutdownEvent);
if(m_ov.hEvent!=NULL)
CloseHandle( m_ov.hEvent );
if(m_hWriteEvent!=NULL)
CloseHandle( m_hWriteEvent );
TRACE("Thread ended\n");
delete [] m_szWriteBuffer;
}
//
// Initialize the port. This can be port 1 to 8.
//
BOOL CSerialPort::InitPort(CWnd* pPortOwner, // the owner (CWnd) of the port (receives message)
UINT portnr, // portnumber (1..4)
UINT baud, // baudrate
char parity, // parity
UINT databits, // databits
UINT stopbits, // stopbits
DWORD dwCommEvents, // EV_RXCHAR, EV_CTS etc
UINT writebuffersize) // size to the writebuffer
{
assert(portnr > 0 && portnr < 9);
assert(pPortOwner != NULL);
// if the thread is alive: Kill
if (m_bThreadAlive)
{
do
{
SetEvent(m_hShutdownEvent);
} while (m_bThreadAlive);
TRACE("Thread ended\n");
}
// create events
if (m_ov.hEvent != NULL)
ResetEvent(m_ov.hEvent);
else
m_ov.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
if (m_hWriteEvent != NULL)
ResetEvent(m_hWriteEvent);
else
m_hWriteEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
if (m_hShutdownEvent != NULL)
ResetEvent(m_hShutdownEvent);
else
m_hShutdownEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
// initialize the event objects
m_hEventArray[0] = m_hShutdownEvent; // highest priority
m_hEventArray[1] = m_ov.hEvent;
m_hEventArray[2] = m_hWriteEvent;
// initialize critical section
InitializeCriticalSection(&m_csCommunicationSync);
// set buffersize for writing and save the owner
m_pOwner = pPortOwner;
if (m_szWriteBuffer != NULL)
delete [] m_szWriteBuffer;
m_szWriteBuffer = new char[writebuffersize];
m_szReadBuffer = new char[40];
m_nPortNr = portnr;
m_nWriteBufferSize = writebuffersize;
m_dwCommEvents = dwCommEvents;
BOOL bResult = FALSE;
char *szPort = new char[50];
char *szBaud = new char[50];
// now it critical!
EnterCriticalSection(&m_csCommunicationSync);
// if the port is already opened: close it
if (m_hComm != NULL)
{
CloseHandle(m_hComm);
m_hComm = NULL;
}
// prepare port strings
sprintf(szPort, "COM%d", portnr);
sprintf(szBaud, "baud=%d parity=%c data=%d stop=%d", baud, parity, databits, stopbits);
// get a handle to the port
m_hComm = CreateFile(szPort, // communication port string (COMX)
GENERIC_READ | GENERIC_WRITE, // read/write types
0, // comm devices must be opened with exclusive access
NULL, // no security attributes
OPEN_EXISTING, // comm devices must use OPEN_EXISTING
FILE_FLAG_OVERLAPPED, // Async I/O
0); // template must be 0 for comm devices
if (m_hComm == INVALID_HANDLE_VALUE)
{
// port not found
delete [] szPort;
delete [] szBaud;
return FALSE;
}
// set the timeout values
m_CommTimeouts.ReadIntervalTimeout = 1000;
m_CommTimeouts.ReadTotalTimeoutMultiplier = 1000;
m_CommTimeouts.ReadTotalTimeoutConstant = 1000;
m_CommTimeouts.WriteTotalTimeoutMultiplier = 1000;
m_CommTimeouts.WriteTotalTimeoutConstant = 1000;
// configure
if (SetCommTimeouts(m_hComm, &m_CommTimeouts))
{
if (SetCommMask(m_hComm, dwCommEvents))
{
if (GetCommState(m_hComm, &m_dcb))
{
m_dcb.EvtChar = parity;
m_dcb.fRtsControl = RTS_CONTROL_ENABLE; // set RTS bit high!
m_dcb.BaudRate = baud;
m_dcb.ByteSize = databits;
m_dcb.StopBits = stopbits;
if (BuildCommDCB(szBaud, &m_dcb))
{
if (SetCommState(m_hComm, &m_dcb))
; // normal operation... continue
else
ProcessErrorMessage("SetCommState()");
}
else
ProcessErrorMessage("BuildCommDCB()");
}
else
ProcessErrorMessage("GetCommState()");
}
else
ProcessErrorMessage("SetCommMask()");
}
else
ProcessErrorMessage("SetCommTimeouts()");
delete [] szPort;
delete [] szBaud;
RA = TRUE;
// flush the port
PurgeComm(m_hComm, PURGE_RXCLEAR | PURGE_TXCLEAR | PURGE_RXABORT | PURGE_TXABORT);
// release critical section
LeaveCriticalSection(&m_csCommunicationSync);
TRACE("Initialisation for communicationport %d completed.\nUse Startmonitor to communicate.\n", portnr);
return TRUE;
}
//
// The CommThread Function.
//
UINT CSerialPort::CommThread(LPVOID pParam)
{
// Cast the void pointer passed to the thread back to
// a pointer of CSerialPort class
CSerialPort *port = (CSerialPort*)pParam;
// Set the status variable in the dialog class to
// TRUE to indicate the thread is running.
port->m_bThreadAlive = TRUE;
// Misc. variables
DWORD BytesTransfered = 0;
DWORD Event = 0;
DWORD CommEvent = 0;
DWORD dwError = 0;
static COMSTAT comstat;
BOOL bResult = TRUE;
// Clear comm buffers at startup
if (port->m_hComm) // check if the port is opened
PurgeComm(port->m_hComm, PURGE_RXCLEAR | PURGE_TXCLEAR | PURGE_RXABORT | PURGE_TXABORT);
// begin forever loop. This loop will run as long as the thread is alive.
for (;;)
{
// Make a call to WaitCommEvent().
// we do this for each port!
bResult = WaitCommEvent(port->m_hComm, &Event, &port->m_ov);
if (!bResult)
{
// If WaitCommEvent() returns FALSE, process the last error to determin
// the reason..
switch (dwError = GetLastError())
{
case ERROR_IO_PENDING:
{
// This is a normal return value if there are no bytes
// to read at the port.
// Do nothing and continue
break;
}
case 87:
{
// Under Windows NT, this value is returned for some reason.
// I have not investigated why, but it is also a valid reply
// Also do nothing and continue.
break;
}
default:
{
// All other error codes indicate a serious error has
// occured. Process this error.
port->ProcessErrorMessage("WaitCommEvent()");
break;
}
}
}
else
{
// If WaitCommEvent() returns TRUE, check to be sure there are
// actually bytes in the buffer to read.
bResult = ClearCommError(port->m_hComm, &dwError, &comstat);
if (comstat.cbInQue == 0)
continue;
} // end if bResult
// Main wait function. This function will normally block the thread
// until one of nine events occur that require action.
Event = WaitForMultipleObjects(3, port->m_hEventArray, FALSE, INFINITE);
switch (Event)
{
case 0:
{
// Shutdown event. This is event zero so it will be
// the higest priority and be serviced first.
CloseHandle(port->m_hComm);
port->m_hComm=NULL;
port->m_bThreadAlive = FALSE;
// Kill this thread. break is not needed, but makes me feel better.
AfxEndThread(100);
delete [] port->m_szReadBuffer;
break;
}
case 1: // read event
{
GetCommMask(port->m_hComm, &CommEvent);
if (CommEvent & EV_RXCHAR)
// Receive character event from port.
ReceiveChar(port, comstat);
if (CommEvent & EV_CTS)
::SendMessage(port->m_pOwner->m_hWnd, WM_COMM_CTS_DETECTED, (WPARAM) 0, (LPARAM) port->m_nPortNr);
if (CommEvent & EV_BREAK)
::SendMessage(port->m_pOwner->m_hWnd, WM_COMM_BREAK_DETECTED, (WPARAM) 0, (LPARAM) port->m_nPortNr);
if (CommEvent & EV_ERR)
::SendMessage(port->m_pOwner->m_hWnd, WM_COMM_ERR_DETECTED, (WPARAM) 0, (LPARAM) port->m_nPortNr);
if (CommEvent & EV_RING)
::SendMessage(port->m_pOwner->m_hWnd, WM_COMM_RING_DETECTED, (WPARAM) 0, (LPARAM) port->m_nPortNr);
if (CommEvent & EV_RXFLAG)
::SendMessage(port->m_pOwner->m_hWnd, WM_COMM_RXFLAG_DETECTED, (WPARAM) 0, (LPARAM) port->m_nPortNr);
break;
}
case 2: // write event
{
// Write character event from port
WriteChar(port);
break;
}
} // end switch
} // close forever loop
return 0;
}
//
// start comm watching
//
BOOL CSerialPort::StartMonitoring()
{
if (!(m_Thread = AfxBeginThread(CommThread, this)))
return FALSE;
TRACE("Thread started\n");
return TRUE;
}
//
// Restart the comm thread
//
BOOL CSerialPort::RestartMonitoring()
{
TRACE("Thread resumed\n");
m_Thread->ResumeThread();
return TRUE;
}
//
// Suspend the comm thread
//
BOOL CSerialPort::StopMonitoring()
{
TRACE("Thread suspended\n");
m_Thread->SuspendThread();
return TRUE;
}
//
// If there is a error, give the right message
//
void CSerialPort::ProcessErrorMessage(char* ErrorText)
{
char *Temp = new char[200];
LPVOID lpMsgBuf;
FormatMessage(
FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
NULL,
GetLastError(),
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
(LPTSTR) &lpMsgBuf,
0,
NULL
);
sprintf(Temp, "WARNING: %s Failed with the following error: \n%s\nPort: %d\n", (char*)ErrorText, lpMsgBuf, m_nPortNr);
MessageBox(NULL, Temp, "Application Error", MB_ICONSTOP);
LocalFree(lpMsgBuf);
delete [] Temp;
}
//
// Write a character.
//
void CSerialPort::WriteChar(CSerialPort* port)
{
BOOL bWrite = TRUE;
BOOL bResult = TRUE;
DWORD BytesSent = 0;
ResetEvent(port->m_hWriteEvent);
// Gain ownership of the critical section
EnterCriticalSection(&port->m_csCommunicationSync);
if (bWrite)
{
// Initailize variables
port->m_ov.Offset = 0;
port->m_ov.OffsetHigh = 0;
// Clear buffer
PurgeComm(port->m_hComm, PURGE_RXCLEAR | PURGE_TXCLEAR | PURGE_RXABORT | PURGE_TXABORT);
bResult = WriteFile(port->m_hComm, // Handle to COMM Port
port->m_szWriteBuffer, // Pointer to message buffer in calling finction
// strlen((char*)port->m_szWriteBuffer), // Length of message to send
port->m_nWriteSize, // Length of message to send
&BytesSent, // Where to store the number of bytes sent
&port->m_ov); // Overlapped structure
// deal with any error codes
if (!bResult)
{
DWORD dwError = GetLastError();
switch (dwError)
{
case ERROR_IO_PENDING:
{
// continue to GetOverlappedResults()
BytesSent = 0;
bWrite = FALSE;
break;
}
default:
{
// all other error codes
port->ProcessErrorMessage("WriteFile()");
}
}
}
else
{
LeaveCriticalSection(&port->m_csCommunicationSync);
}
} // end if(bWrite)
if (!bWrite)
{
bWrite = TRUE;
bResult = GetOverlappedResult(port->m_hComm, // Handle to COMM port
&port->m_ov, // Overlapped structure
&BytesSent, // Stores number of bytes sent
TRUE); // Wait flag
LeaveCriticalSection(&port->m_csCommunicationSync);
// deal with the error code
// if (!bResult)
{
// port->ProcessErrorMessage("GetOverlappedResults() in WriteFile()");
}
} // end if (!bWrite)
//Verify that the data size send equals what we tried to send
if (BytesSent != port->m_nWriteSize) // Length of message to send)
{
TRACE("WARNING: WriteFile() error.. Bytes Sent: %d; Message Length: %d\n", BytesSent, strlen((char*)port->m_szWriteBuffer));
}
// ::SendMessage((port->m_pOwner)->m_hWnd, WM_COMM_TXEMPTY_DETECTED, (WPARAM) RXBuff, (LPARAM) port->m_nPortNr);
// ::SendMessage((port->m_pOwner)->m_hWnd, WM_COMM_TXEMPTY_DETECTED,0,(LPARAM) port->m_nPortNr);
}
//
// Character received. Inform the owner
//
void CSerialPort::ReceiveChar(CSerialPort* port, COMSTAT comstat)
{
BOOL bRead = TRUE;
BOOL bResult = TRUE;
DWORD dwError = 0;
DWORD BytesRead = 40;
//unsigned char RXBuff;
memset(port->m_szReadBuffer,0,40);
for (;;)
{
if(RA == FALSE)
{
return;
}
// Gain ownership of the comm port critical section.
// This process guarantees no other part of this program
// is using the port object.
EnterCriticalSection(&port->m_csCommunicationSync);
// ClearCommError() will update the COMSTAT structure and
// clear any other errors.
bResult = ClearCommError(port->m_hComm, &dwError, &comstat);
LeaveCriticalSection(&port->m_csCommunicationSync);
// start forever loop.
if (comstat.cbInQue == 0)
{
// break out when all bytes have been read
break;
}
EnterCriticalSection(&port->m_csCommunicationSync);
if (bRead)
{
bResult = ReadFile(port->m_hComm, // Handle to COMM port
port->m_szReadBuffer, // RX Buffer Pointer
BytesRead, // Read one byte
&BytesRead, // Stores number of bytes read
&port->m_ov); // pointer to the m_ov structure
// deal with the error code
if (!bResult)
{
switch (dwError = GetLastError())
{
case ERROR_IO_PENDING:
{
// asynchronous i/o is still in progress
// Proceed on to GetOverlappedResults();
bRead = FALSE;
break;
}
default:
{
// Another error has occured. Process this error.
port->ProcessErrorMessage("ReadFile()");
break;
}
}
}
else
{
// ReadFile() returned complete. It is not necessary to call GetOverlappedResults()
bRead = TRUE;
}
} // close if (bRead)
if (!bRead)
{
bRead = TRUE;
bResult = GetOverlappedResult(port->m_hComm, // Handle to COMM port
&port->m_ov, // Overlapped structure
&BytesRead, // Stores number of bytes read
TRUE); // Wait flag
// deal with the error code
if (!bResult)
{
port->ProcessErrorMessage("GetOverlappedResults() in ReadFile()");
}
} // close if (!bRead)
LeaveCriticalSection(&port->m_csCommunicationSync);
// notify parent that a byte was received
::SendMessage((port->m_pOwner)->m_hWnd, WM_COMM_RXCHAR, (WPARAM) (port->m_szReadBuffer), (LPARAM) port->m_nPortNr);
} // end forever loop
}
//
// Write a string to the port
//
void CSerialPort::WriteToPort(char* string)
{
assert(m_hComm != 0);
memset(m_szWriteBuffer, 0, sizeof(m_szWriteBuffer));
strcpy(m_szWriteBuffer, string);
m_nWriteSize=strlen(string);
// set event for write
SetEvent(m_hWriteEvent);
}
void CSerialPort::WriteToPort(char* string,int n)
{
assert(m_hComm != 0);
memset(m_szWriteBuffer, 0, sizeof(m_szWriteBuffer));
// memset(m_szWriteBuffer, 0, n);
// strncpy(m_szWriteBuffer, string, n);
memcpy(m_szWriteBuffer, string, n);
m_nWriteSize=n;
// set event for write
SetEvent(m_hWriteEvent);
}
void CSerialPort::WriteToPort(LPCTSTR string)
{
assert(m_hComm != 0);
memset(m_szWriteBuffer, 0, sizeof(m_szWriteBuffer));
strcpy(m_szWriteBuffer, string);
m_nWriteSize=strlen(string);
// set event for write
SetEvent(m_hWriteEvent);
}
void CSerialPort::WriteToPort(LPCTSTR string,int n)
{
assert(m_hComm != 0);
memset(m_szWriteBuffer, 0, sizeof(m_szWriteBuffer));
// strncpy(m_szWriteBuffer, string, n);
memcpy(m_szWriteBuffer, string, n);
m_nWriteSize=n;
// set event for write
SetEvent(m_hWriteEvent);
}
//
// Return the device control block
//
DCB CSerialPort::GetDCB()
{
return m_dcb;
}
//
// Return the communication event masks
//
DWORD CSerialPort::GetCommEvents()
{
return m_dwCommEvents;
}
//
// Return the output buffer size
//
DWORD CSerialPort::GetWriteBufferSize()
{
return m_nWriteBufferSize;
}
void CSerialPort::ClosePort()
{
RA = FALSE;
SetEvent(m_hShutdownEvent);
}
⑧ VC串口通信問題
串口的操作可以有兩種操作方式：同步操作方式和重疊操作方式（又稱為非同步操作方式）。同步操作時，API函數會阻塞直到操作完成以後才能返回（在多線程方式中，雖然不會阻塞主線程，但是仍然會阻塞監聽線程）；而重疊操作方式，API函數會立即返回，操作在後台進行，避免線程的阻塞。
無論那種操作方式，一般都通過四個步驟來完成：
（1） 打開串口
（2） 配置串口
（3） 讀寫串口
（4） 關閉串口
（1） 打開串口
Win32系統把文件的概念進行了擴展。無論是文件、通信設備、命名管道、郵件槽、磁碟、還是控制台，都是用API函數CreateFile來打開或創建的。該函數的原型為：
lpFileName：將要打開的串口邏輯名，如「COM1」；
dwDesiredAccess：指定串口訪問的類型，可以是讀取、寫入或二者並列；
dwShareMode：指定共享屬性，由於串口不能共享，該參數必須置為0；
lpSecurityAttributes：引用安全性屬性結構，預設值為NULL；
dwCreationDistribution：創建標志，對串口操作該參數必須置為OPEN_EXISTING；
dwFlagsAndAttributes：屬性描述，用於指定該串口是否進行非同步操作，該值為FILE_FLAG_OVERLAPPED，表示使用非同步的I/O；該值為0，表示同步I/O操作；
hTemplateFile：對串口而言該參數必須置為NULL；
同步I/O方式打開串口的示例代碼：
HANDLE hCom; //全局變數，串口句柄
hCom=CreateFile("COM1",//COM1口
GENERIC_READ|GENERIC_WRITE, //允許讀和寫
0, //獨占方式
NULL,
OPEN_EXISTING, //打開而不是創建
0, //同步方式
NULL);
if(hCom==(HANDLE)-1)
{
AfxMessageBox("打開COM失敗!");
return FALSE;
}
return TRUE;
（2）、配置串口
在打開通訊設備句柄後，常常需要對串口進行一些初始化配置工作。這需要通過一個DCB結構來進行。DCB結構包含了諸如波特率、數據位數、奇偶校驗和停止位數等信息。在查詢或配置串口的屬性時，都要用DCB結構來作為緩沖區。
一般用CreateFile打開串口後，可以調用GetCommState函數來獲取串口的初始配置。要修改串口的配置，應該先修改DCB結構，然後再調用SetCommState函數設置串口。
typedef struct _DCB{
………
//波特率，指定通信設備的傳輸速率。這個成員可以是實際波特率值或者下面的常量值之一：
DWORD BaudRate;
CBR_110，CBR_300，CBR_600，CBR_1200，CBR_2400，CBR_4800，CBR_9600，CBR_19200， CBR_38400，
CBR_56000， CBR_57600， CBR_115200， CBR_128000， CBR_256000， CBR_14400
DWORD fParity; // 指定奇偶校驗使能。若此成員為1，允許奇偶校驗檢查
…
BYTE ByteSize; // 通信位元組位數，4—8
BYTE Parity; //指定奇偶校驗方法。此成員可以有下列值：
EVENPARITY 偶校驗 NOPARITY 無校驗
MARKPARITY 標記校驗 ODDPARITY 奇校驗
BYTE StopBits; //指定停止位的位數。此成員可以有下列值：
ONESTOPBIT 1位停止位 TWOSTOPBITS 2位停止位
ONE5STOPBITS 1.5位停止位
………
} DCB;
winbase.h文件中定義了以上用到的常量。如下：
#define NOPARITY 0
#define ODDPARITY 1
#define EVENPARITY 2
#define ONESTOPBIT 0
#define ONE5STOPBITS 1
#define TWOSTOPBITS 2
#define CBR_110 110
#define CBR_300 300
#define CBR_600 600
#define CBR_1200 1200
#define CBR_2400 2400
#define CBR_4800 4800
#define CBR_9600 9600
#define CBR_14400 14400
#define CBR_19200 19200
#define CBR_38400 38400
#define CBR_56000 56000
#define CBR_57600 57600
#define CBR_115200 115200
#define CBR_128000 128000
#define CBR_256000 256000
GetCommState函數可以獲得COM口的設備控制塊，從而獲得相關參數： BOOL GetCommState(
HANDLE hFile, //標識通訊埠的句柄
LPDCB lpDCB //指向一個設備控制塊（DCB結構）的指針
);
SetCommState函數設置COM口的設備控制塊：
BOOL SetCommState(
HANDLE hFile,
LPDCB lpDCB
);
除了在BCD中的設置外，程序一般還需要設置I/O緩沖區的大小和超時。Windows用I/O緩沖區來暫存串口輸入和輸出的數據。如果通信的速率較高，則應該設置較大的緩沖區。調用SetupComm函數可以設置串列口的輸入和輸出緩沖區的大小。 BOOL SetupComm(
HANDLE hFile, // 通信設備的句柄
DWORD dwInQueue, // 輸入緩沖區的大小（位元組數）
DWORD dwOutQueue // 輸出緩沖區的大小（位元組數）
);
在用ReadFile和WriteFile讀寫串列口時，需要考慮超時問題。超時的作用是在指定的時間內沒有讀入或發送指定數量的字元，ReadFile或WriteFile的操作仍然會結束。
要查詢當前的超時設置應調用GetCommTimeouts函數，該函數會填充一個COMMTIMEOUTS結構。調用SetCommTimeouts可以用某一個COMMTIMEOUTS結構的內容來設置超時。
讀寫串口的超時有兩種：間隔超時和總超時。間隔超時是指在接收時兩個字元之間的最大時延。總超時是指讀寫操作總共花費的最大時間。寫操作只支持總超時，而讀操作兩種超時均支持。用COMMTIMEOUTS結構可以規定讀寫操作的超時。
COMMTIMEOUTS結構的定義為： typedef struct _COMMTIMEOUTS {
DWORD ReadIntervalTimeout; //讀間隔超時
DWORD ReadTotalTimeoutMultiplier; //讀時間系數
DWORD ReadTotalTimeoutConstant; //讀時間常量
DWORD WriteTotalTimeoutMultiplier; // 寫時間系數
DWORD WriteTotalTimeoutConstant; //寫時間常量
} COMMTIMEOUTS,*LPCOMMTIMEOUTS;
COMMTIMEOUTS結構的成員都以毫秒為單位。總超時的計算公式是：
總超時＝時間系數×要求讀/寫的字元數＋時間常量
例如，要讀入10個字元，那麼讀操作的總超時的計算公式為：
讀總超時＝ReadTotalTimeoutMultiplier×10＋ReadTotalTimeoutConstant
可以看出：間隔超時和總超時的設置是不相關的，這可以方便通信程序靈活地設置各種超時。
如果所有寫超時參數均為0，那麼就不使用寫超時。如果ReadIntervalTimeout為0，那麼就不使用讀間隔超時。如果ReadTotalTimeoutMultiplier 和 ReadTotalTimeoutConstant 都為0，則不使用讀總超時。如果讀間隔超時被設置成MAXDWORD並且讀時間系數和讀時間常量都為0，那麼在讀一次輸入緩沖區的內容後讀操作就立即返回，而不管是否讀入了要求的字元。
在用重疊方式讀寫串口時，雖然ReadFile和WriteFile在完成操作以前就可能返回，但超時仍然是起作用的。在這種情況下，超時規定的是操作的完成時間，而不是ReadFile和WriteFile的返回時間。
配置串口的示例代碼： SetupComm(hCom,1024,1024); //輸入緩沖區和輸出緩沖區的大小都是1024
COMMTIMEOUTS TimeOuts;
//設定讀超時
TimeOuts.ReadIntervalTimeout=1000;
TimeOuts.ReadTotalTimeoutMultiplier=500;
TimeOuts.ReadTotalTimeoutConstant=5000;
//設定寫超時
TimeOuts.WriteTotalTimeoutMultiplier=500;
TimeOuts.WriteTotalTimeoutConstant=2000;
SetCommTimeouts(hCom,&TimeOuts); //設置超時
DCB dcb;
GetCommState(hCom,&dcb);
dcb.BaudRate=9600; //波特率為9600
dcb.ByteSize=8; //每個位元組有8位
dcb.Parity=NOPARITY; //無奇偶校驗位
dcb.StopBits=TWOSTOPBITS; //兩個停止位
SetCommState(hCom,&dcb);
PurgeComm(hCom,PURGE_TXCLEAR|PURGE_RXCLEAR);
在讀寫串口之前，還要用PurgeComm()函數清空緩沖區，該函數原型： BOOL PurgeComm(
HANDLE hFile, //串口句柄
DWORD dwFlags // 需要完成的操作
);
參數dwFlags指定要完成的操作，可以是下列值的組合： PURGE_TXABORT 中斷所有寫操作並立即返回，即使寫操作還沒有完成。
PURGE_RXABORT 中斷所有讀操作並立即返回，即使讀操作還沒有完成。
PURGE_TXCLEAR 清除輸出緩沖區
PURGE_RXCLEAR 清除輸入緩沖區
（3）、讀寫串口
我們使用ReadFile和WriteFile讀寫串口，下面是兩個函數的聲明：
BOOL ReadFile(
HANDLE hFile, //串口的句柄
// 讀入的數據存儲的地址，
// 即讀入的數據將存儲在以該指針的值為首地址的一片內存區
LPVOID lpBuffer,
DWORD nNumberOfBytesToRead, // 要讀入的數據的位元組數
// 指向一個DWORD數值，該數值返回讀操作實際讀入的位元組數
LPDWORD lpNumberOfBytesRead,
// 重疊操作時，該參數指向一個OVERLAPPED結構，同步操作時，該參數為NULL。
LPOVERLAPPED lpOverlapped
);
BOOL WriteFile(
HANDLE hFile, //串口的句柄
// 寫入的數據存儲的地址，
// 即以該指針的值為首地址的nNumberOfBytesToWrite
// 個位元組的數據將要寫入串口的發送數據緩沖區。
LPCVOID lpBuffer,
DWORD nNumberOfBytesToWrite, //要寫入的數據的位元組數
// 指向指向一個DWORD數值，該數值返回實際寫入的位元組數
LPDWORD lpNumberOfBytesWritten,
// 重疊操作時，該參數指向一個OVERLAPPED結構，
// 同步操作時，該參數為NULL。
LPOVERLAPPED lpOverlapped
);
在用ReadFile和WriteFile讀寫串口時，既可以同步執行，也可以重疊執行。在同步執行時，函數直到操作完成後才返回。這意味著同步執行時線程會被阻塞，從而導致效率下降。在重疊執行時，即使操作還未完成，這兩個函數也會立即返回，費時的I/O操作在後台進行。
ReadFile和WriteFile函數是同步還是非同步由CreateFile函數決定，如果在調用CreateFile創建句柄時指定了FILE_FLAG_OVERLAPPED標志，那麼調用ReadFile和WriteFile對該句柄進行的操作就應該是重疊的；如果未指定重疊標志，則讀寫操作應該是同步的。ReadFile和WriteFile函數的同步或者非同步應該和CreateFile函數相一致。
ReadFile函數只要在串口輸入緩沖區中讀入指定數量的字元，就算完成操作。而WriteFile函數不但要把指定數量的字元拷入到輸出緩沖區，而且要等這些字元從串列口送出去後才算完成操作。
如果操作成功，這兩個函數都返回TRUE。需要注意的是，當ReadFile和WriteFile返回FALSE時，不一定就是操作失敗，線程應該調用GetLastError函數分析返回的結果。例如，在重疊操作時如果操作還未完成函數就返回，那麼函數就返回FALSE，而且GetLastError函數返回ERROR_IO_PENDING。這說明重疊操作還未完成。
您可以觀察返回的字元串，其中有和儀表顯示值相同的部分，您可以進行相應的字元串操作取出儀表的顯示值。
打開ClassWizard,為靜態文本框IDC_DISP添加CString類型變數m_disp，同時添加WM_CLOSE的相應函數： void CRS485CommDlg::OnClose()
{
// TODO: Add your message handler code here and/or call default
CloseHandle(hCom); //程序退出時關閉串口
CDialog::OnClose();
}
程序的相應部分已經在代碼內部作了詳細介紹。連接好硬體部分，編譯運行程序，細心體會串口同步操作部分。
常式2
打開VC++6.0，新建基於對話框的工程RS485Comm，在主對話框窗口IDD_RS485COMM_DIALOG上添加兩個按鈕，ID分別為IDC_SEND和IDC_RECEIVE，標題分別為「發送」和「接收」；添加一個靜態文本框IDC_DISP，用於顯示串口接收到的內容。在RS485CommDlg.cpp文件中添加全局變數：
HANDLE hCom; //全局變數，
串口句柄在RS485CommDlg.cpp文件中的OnInitDialog()函數添加如下代碼：
hCom=CreateFile("COM1",//COM1口
GENERIC_READ|GENERIC_WRITE, //允許讀和寫
0, //獨占方式
NULL,
OPEN_EXISTING, //打開而不是創建
FILE_ATTRIBUTE_NORMAL|FILE_FLAG_OVERLAPPED, //重疊方式
NULL);
if(hCom==(HANDLE)-1)
{
AfxMessageBox("打開COM失敗!");
return FALSE;
}
SetupComm(hCom,100,100); //輸入緩沖區和輸出緩沖區的大小都是100
COMMTIMEOUTS TimeOuts;
//設定讀超時
TimeOuts.ReadIntervalTimeout=MAXDWORD;
TimeOuts.ReadTotalTimeoutMultiplier=0;
TimeOuts.ReadTotalTimeoutConstant=0;
//在讀一次輸入緩沖區的內容後讀操作就立即返回，
//而不管是否讀入了要求的字元。
//設定寫超時
TimeOuts.WriteTotalTimeoutMultiplier=100;
TimeOuts.WriteTotalTimeoutConstant=500;
SetCommTimeouts(hCom,&TimeOuts); //設置超時
DCB dcb;
GetCommState(hCom,&dcb);
dcb.BaudRate=9600; //波特率為9600
dcb.ByteSize=8; //每個位元組有8位
dcb.Parity=NOPARITY; //無奇偶校驗位
dcb.StopBits=TWOSTOPBITS; //兩個停止位
SetCommState(hCom,&dcb);
PurgeComm(hCom,PURGE_TXCLEAR|PURGE_RXCLEAR);
分別雙擊IDC_SEND按鈕和IDC_RECEIVE按鈕，添加兩個按鈕的響應函數： void CRS485CommDlg::OnSend()
{
// TODO: Add your control notification handler code here
OVERLAPPED m_osWrite;
memset(&m_osWrite,0,sizeof(OVERLAPPED));
m_osWrite.hEvent=CreateEvent(NULL,TRUE,FALSE,NULL);
char lpOutBuffer[7];
memset(lpOutBuffer,''\0'',7);
lpOutBuffer[0]=''\x11'';
lpOutBuffer[1]=''0'';
lpOutBuffer[2]=''0'';
lpOutBuffer[3]=''1'';
lpOutBuffer[4]=''0'';
lpOutBuffer[5]=''1'';
lpOutBuffer[6]=''\x03'';
DWORD dwBytesWrite=7;
COMSTAT ComStat;
DWORD dwErrorFlags;
BOOL bWriteStat;
ClearCommError(hCom,&dwErrorFlags,&ComStat);
bWriteStat=WriteFile(hCom,lpOutBuffer,
dwBytesWrite,& dwBytesWrite,&m_osWrite);
if(!bWriteStat)
{
if(GetLastError()==ERROR_IO_PENDING)
{
WaitForSingleObject(m_osWrite.hEvent,1000);
}
}
}
void CRS485CommDlg::OnReceive()
{
// TODO: Add your control notification handler code here
OVERLAPPED m_osRead;
memset(&m_osRead,0,sizeof(OVERLAPPED));
m_osRead.hEvent=CreateEvent(NULL,TRUE,FALSE,NULL);
COMSTAT ComStat;
DWORD dwErrorFlags;
char str[100];
memset(str,''\0'',100);
DWORD dwBytesRead=100;//讀取的位元組數
BOOL bReadStat;
ClearCommError(hCom,&dwErrorFlags,&ComStat);
dwBytesRead=min(dwBytesRead, (DWORD)ComStat.cbInQue);
bReadStat=ReadFile(hCom,str,
dwBytesRead,&dwBytesRead,&m_osRead);
if(!bReadStat)
{
if(GetLastError()==ERROR_IO_PENDING)
//GetLastError()函數返回ERROR_IO_PENDING,表明串口正在進行讀操作
{
WaitForSingleObject(m_osRead.hEvent,2000);
//使用WaitForSingleObject函數等待，直到讀操作完成或延時已達到2秒鍾
//當串口讀操作進行完畢後，m_osRead的hEvent事件會變為有信號
}
}
PurgeComm(hCom, PURGE_TXABORT|
PURGE_RXABORT|PURGE_TXCLEAR|PURGE_RXCLEAR);
m_disp=str;
UpdateData(FALSE);
}
打開ClassWizard,為靜態文本框IDC_DISP添加CString類型變數m_disp，同時添加WM_CLOSE的相應函數： void CRS485CommDlg::OnClose()
{
// TODO: Add your message handler code here and/or call default
CloseHandle(hCom); //程序退出時關閉串口
CDialog::OnClose();
}
這是我看過的一個資料。打開、設置和讀寫串口的方法都說的很詳細了。由於網路知道回答問題是有長度限制的。有些例子被我刪了。如果需要就加我QQ。給你發信息了。
⑨ 求：《visual C++串口通信開發入門與編程實踐》周韌研、商斌編著這本書的實例源代碼！
Visual C++_Turbo C串口通信編程實踐
不錯，循序漸進！
⑩ VisualBasic串口通信程序設計
1mscomm.vbx通信控制項描述
mscomm.vbx通信控制項可直接從vb的toolbox中加入窗體form，即可用其進行通信。若toolbox中無此控制項，則用tools的customcontrols將mscomm.vbx從windows的system子目錄中加入vb的toolbox中。
1.1通信方式
mscomm.vbx有2種不同的方式來處理和解決各類通信軟體的開發和設計問題
1、事件驅動。它與c/c 寫windows軟體時的窗口回調函數類似，是1種功能強大的處理問題的方法。在實際工作中，往往要處理許多通信中的相關事件，例如：當線路數據到達本端或cd線和rts信號線狀態發生變化時，要求我們使用相應的事件來跟蹤和處理，該控制項是使用oncomm事件來實現的，它也包括檢測和處理通信錯誤等方面的問題，commevent值返回最近的通信事件或錯誤的數字代碼。通信控制項詳細的錯誤和事件舉例有：
mscomm-er-break收到1個breaksignal
mscomm-er-cdtocd信號超時
mscomm-ev-cdcd信號改變
2、查缺此詢方式。由程序設計者負責讀取commevent的值並處理所發生的錯誤或事件。通常簡單的應用程序設計可採用這種辦法。
1.2通信控制項的屬性
利用通信控制項編制通信程序，關鍵是准確理解設置通信控制項的屬性。mscomm.vbx提供了27個關於通信控制項方面的屬性，例如：
commport：設置或返回通信口編號。
settings：設置或返回以字元串形式出現的數據通信格式：波特率、校驗、數據位和停止位。
portopen：設置或返回通信口狀態（包括打開和關閉1個通信口）
3、實例
本程序應用背景為dcc95型靜電除塵器自動監控系統軟體，解決1個pc工控機（主站）與32個單片機（宴扮子站）之間的通信問題。主站與子站之間這匯流排式網路結構，採用rs-485通信標准，以問答方式進行數據通信。由於32個子站與主站發送通信命令（下行命令），主站在接收子站發回的相應回答命令（上行命令）後繼續發送下行命令的通信形式。根據系統功能的要求，主站需發送2種類型的命令：（1）同期命令，它由定時器觸發引起，每隔ls周期發送1次；（2）非周期性命令，它由操作者按動相應命令按鈕引起，非周期性發送。自動監控系統軟體安裝在主站上，而通信程序作為自動監控系統軟體的一部分也安裝在主站上。
本文僅列出調試通信程序時進行試驗用的基本演示程序清單。試驗時，用1台pc機作為主站，另一台pc機模擬32個子站的工作，兩台pc機之間採用rs232c串口通信。往主站的通信演示程序窗體（form）中加入1個通信控制項、2個定時器控制項和1個命令按鈕控制項，通信控制項（mscomm1）用於訪問串口，發送和接收數據；periodic定時器控制項（periodic）用於控制每秒由主站向各子站發送周期性命令；命令按鈕控制項(nonperiodic-command)與nonperiodic定時器控制項（nonperiodic）用於發送非周期性命令。數據傳送採用事件驅動的通信方式，根據不同的發送命令設置rtreshlod屬性，從而引起oncomm事件以接收數據。
2.1窗體各控制項初始化程序
設置通信串口工作參數，設置periodic定時器的在斷間隔為ls,nonperiodic定時器的中斷間隔為0.5s。
subform-load()
mscomm1.commport=2'選用com2串列口
mscomm1.settings="9600，n8，1"'波特率9600，無奇偶校驗位，8位數據位1位停止位
mscomm1.inputlen=0'input將讀取接收緩沖區的全部內容
mscomm1.inbuffersize=1024'設置接收緩沖區伏祥迅的位元組長度
mscomm1.portopen=true'打開通信口
mscomm1.inbuffercount=0'清除發送緩沖區數據
mscomm1.outbuffercount=0'清除接收緩沖區數據
periodic.inteval=100'設置ls定時間隔，使遙測命令每隔ls發送1次
nonperiodic.inteval=500'設置0.5s定時間隔，查詢命令按鈕是否處於激活狀態以確定是否發送周期性命令
command-pressed=false'命令按鈕為未激活狀態
ring-periodic=false'周期性命令數據傳輸尚未開始
ring-nonperiodic=false'非周期性命令數據傳輸尚未開始
endsub
2.2非周期性命令發送程序
根據命令按鈕狀態及周期性命令數據傳輸狀態，在nonperiodic定時器的中斷程序中發送非周期性命令。
subnonperiodic-command-click()
command-pressed=true'命令按鈕激活
endsub
subnonperiodic-timer()
ifring-periodic=trueorcommand-pressed=false
thenexitsub'若周期性命令數據傳輸尚未結束或命令按鈕處於激活狀態，則退出發送非周期性命令程序。
command-pressed=false'命令按鈕恢復為未激活狀態
callsenddata(nonperiodic-command)'發送非周期性命令
mscomm1.rthreshold=r-nonperiodic-byte'發送非周期性命令後，設置rthreshold屬性，使主站接收所設定的位元組數後引發oncomm事件
endsub
2.3periodic定時器程序
在periodic定時器的中斷程序中發送周期性命令：
subperiodic-timer()
ifring-nonperiodic=truethenexitsub'若非周期性命令數據傳輸尚未結束，則退出發送非周期性命令程序。
ring-periodic=true'設置周期性命令數據傳輸狀態為正在進行中
callsenddata(periodic-command)'發送周期性命令
mscomm1.rthreshold=r-periodic-byte'發送周期性命令後，主站接收r-remot-edata-byte個位元組，可引發oncomm事件
endsub
2.4oncomm事件程序
根據rthreshold屬性設置值，當接收緩存區內接收到相應位元組的字元時，引發oncomm事件，在中斷程序中接收數據。
submscomm1-oncomm()
selectcasemscomm1.commevent'在此可插入處理各種不同錯誤或事件的代碼
casemscomm-ev-receive
receivestring$=mscomm1.input
selectcasemscomm1.rthreshold
caser-periodic-byte'周期性命令的應答數據
calldisposedata(periodic-command)'處理接收數據
ringperiodic=false'設置周期性命令數據傳輸狀態為結束
caser-nonperiodic-byte'非周期性命令的應答數據
calldisposedata(nonperiodic-command)'處理接收數據
ring-nonperiodic=false'設置非周期性命令數據傳輸狀態為結束
endselect
endselect
endsub
隨著vb版本的不斷升級，vb將成為最快速、易用、強勁的應用開發工具，是企業級客戶/伺服器應用軟體開發的首選工具之一。