cserial.cpp

一个基于PXA255的水情遥测、遥控系统现场服务器软件

// Serial.cpp: implementation of the CSerial class.
//
/*int CSerial::GetData(char *address,int ionum)控制开关
address地址，
//tnum 开关号0－6
int CSerial::CheckhOP(char *address)检测开关
address地址
BOOL CSerial::ContralOP(char* address, int tnum,int op)控制开关
//控制命令第一个是地址00-99两位
//tnum 通道号0－7
//第二个是通断0/1;1开
*/
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "resource.h"
#include "CSerial.h"

#include <atlconv.h>
#include <stdio.h>
/*
typedef struct {
	int IONUM;
	char Address[3];//终端地址
	int  Gdata;//获得的数据
	int  OC;//开关
} Ser_Parameter; 
*/
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CSerial::CSerial()
{
	m_hIDComDev = NULL;
	m_bOpened = FALSE;
}

CSerial::~CSerial()
{
	PortClose();
}

BOOL CSerial::Open(int nPort, int nBaud)
{

	if( m_bOpened ) return( TRUE );

	TCHAR szPort[15];
	DCB dcb;

	wsprintf( szPort, _T("COM%d:"), nPort );
	m_hIDComDev = CreateFile( szPort,
		GENERIC_READ | GENERIC_WRITE,
		0,
		NULL,
		OPEN_EXISTING,
		0,
		NULL 
		);

	if( m_hIDComDev == INVALID_HANDLE_VALUE)
	{
		DWORD dwError=GetLastError();
		::MessageBox(0,_T("Init Error!"),_T("ERROR!"),MB_OK );
		return( FALSE );
	}
	else
	{
		m_bOpened = TRUE;
	}

	// Change the CommTimeOuts structure settings.
	COMMTIMEOUTS CommTimeOuts;
	GetCommTimeouts (szPort, &CommTimeOuts);

    CommTimeOuts.ReadIntervalTimeout = MAXDWORD;  
    CommTimeOuts.ReadTotalTimeoutMultiplier = 0;  
    CommTimeOuts.ReadTotalTimeoutConstant = 0;    
    CommTimeOuts.WriteTotalTimeoutMultiplier = 0;  
    CommTimeOuts.WriteTotalTimeoutConstant = 0;    

	if(!SetCommTimeouts( m_hIDComDev, &CommTimeOuts ))
	{
		//could not creatthe read thread;
		 ::MessageBox (NULL,_T("Init Error!"),_T("ERROR"),MB_OK);
		 DWORD dwError=GetLastError();
		 return FALSE;
	}

	dcb.DCBlength = sizeof( DCB );
	GetCommState( m_hIDComDev, &dcb );
	dcb.BaudRate = nBaud;

    dcb.fBinary = TRUE;               // Binary mode; no EOF check 
    dcb.fParity = TRUE;               // Enable parity checking 
    dcb.fOutxCtsFlow = FALSE;         // No CTS output flow control 
    dcb.fOutxDsrFlow = FALSE;         // No DSR output flow control 
    dcb.fDtrControl = DTR_CONTROL_ENABLE; 
                                      // DTR flow control type 
    dcb.fDsrSensitivity = FALSE;      // DSR sensitivity 
    dcb.fTXContinueOnXoff = TRUE;     // XOFF continues Tx 
    dcb.fOutX = FALSE;                // No XON/XOFF out flow control 
    dcb.fInX = TRUE;                 // No XON/XOFF in flow control 
    dcb.fErrorChar = FALSE;           // Disable error replacement 
    dcb.fNull = FALSE;                // Disable null stripping 
    dcb.fRtsControl = RTS_CONTROL_ENABLE; 
                                      // RTS flow control 
    dcb.fAbortOnError = FALSE;        // Do not abort reads/writes on 
                                      // error
    dcb.ByteSize = 8;                 // Number of bits/byte, 4-8 
    dcb.Parity = 0;            // 0-4=no,odd,even,mark,space 
    dcb.StopBits = ONE5STOPBITS;        // 0,1,2 = 1, 1.5, 2 


	if( !SetCommState( m_hIDComDev, &dcb )||
	!SetupComm( m_hIDComDev, 1024, 1024 )/*||
										 m_OverlappedRead.hEvent == NULL ||
										 m_OverlappedWrite.hEvent == NULL*/ )
	{
		DWORD dwError = GetLastError();
		//if( m_OverlappedRead.hEvent != NULL ) CloseHandle( m_OverlappedRead.hEvent );
		//if( m_OverlappedWrite.hEvent != NULL ) CloseHandle( m_OverlappedWrite.hEvent );
		CloseHandle( m_hIDComDev );
		::MessageBox(0,_T("Init Error!"),_T("ERROR!"),MB_OK );
		return( FALSE );
	}
	
	else
	{
	}
	
	m_bOpened = TRUE;
	return( m_bOpened );
}

//======================
BOOL CSerial::PortClose (void)
{
	if (m_bOpened)
	{
		// Close the communication port.
		if (!CloseHandle (m_hIDComDev))
		{
			DWORD dwError = GetLastError ();
		}
		else
		{
			//::MessageBox (NULL,_T("正常退出，谢谢使用!"),_T("RIGHT"),MB_OK);   }
			m_bOpened = FALSE;
		}
	}
	else
	{
		return(FALSE); 
	}
	return( TRUE );  
}

/*BOOL CSerial::SendData(CString SData )
{
	//char * buffer=SData.GetBuffer(SData.GetLength());
	DWORD dwNumByteWritten;
	if(!WriteFile(m_hIDComDev,SData,SData.GetLength()*2,&dwNumByteWritten,NULL))
	{
		DWORD dwError = GetLastError();
		return FALSE;
	}
	return TRUE;
}
*/
BOOL CSerial::SendData(char *buffer, int size )
{
	DWORD dwNumByteWritten;
	if(!WriteFile(m_hIDComDev,buffer,size,&dwNumByteWritten,NULL))
	{
		DWORD dwError = GetLastError();
		return FALSE;
	}
	return TRUE;
}

int CSerial::ReadData(char *data )
{
    char Byte;
	DWORD dwCommModemStatus,dwBytesTransferred;
	int len = 0;
	SetCommMask (m_hIDComDev, EV_RXCHAR);
	if (m_hIDComDev!= INVALID_HANDLE_VALUE) 
	{
		WaitCommEvent (m_hIDComDev, &dwCommModemStatus, 0);
		SetCommMask (m_hIDComDev, EV_RXCHAR | EV_CTS | EV_DSR );
		if (dwCommModemStatus & EV_RXCHAR) 
		{
			do 
			{
				// Read the data from the serial port.
				ReadFile (m_hIDComDev,
					&Byte, 
					1, 
					&dwBytesTransferred,
					0
					);
	
				if (dwBytesTransferred == 1)
				{
					data[len] = Byte;
					data[len+1] = 0;
					len++;
				}
			}
			while (dwBytesTransferred == 1);
		}   
	}
	return len;
}

int CSerial::GetData(char *address,int ionum)
{
	    char szMessage[10];
		char  *buff=new char[50];
		sprintf(szMessage, "AA1%s%d00BB", address,ionum);
		int nBytesSent;
    	nBytesSent=SendData(szMessage,strlen(szMessage));
		Sleep(50);
		NReadData(buff);
        nBytesSent=SendData(szMessage,strlen(szMessage));
		
		int i=NReadData(buff);//读两遍以防没读到。
		if(i==0)
            i=NReadData(buff);
		if(i){
			char  Gdata[3];        
			strncpy(Gdata,buff+4,2);//取得传送来的4位16进制;
		    Gdata[3]='\0';
			delete[] buff;
			if((int)Gdata[1]<0)
			return (((int)Gdata[0])*256+(int)Gdata[1]+256);
			else
			return (((int)Gdata[0])*256+(int)Gdata[1]);
		}
		else
		{
		//	AfxMessageBox(_T("Get Data Error!"));
			return 0;
		}

}

BOOL CSerial::ContralOP(char* address, int tnum,int op)//控制命令第一个是地址00-99
{											   //第二个是通断.
	
	char szMessage[10];
	sprintf(szMessage, "AA2%s1%d%dBB", address,tnum,op);
	int nBytesSent;
   	nBytesSent=SendData(szMessage,strlen(szMessage));		
	return TRUE;
}

int CSerial::CheckhOP(char *address)
{
        char szMessage[10];
	    sprintf(szMessage,"AA3%s000BB", address);
		int nBytesSent;
    	nBytesSent=SendData(szMessage,strlen(szMessage));
		char  *buff=new char[50];
		if(NReadData(buff))
		{
		    char  Gdata[3];  
		    strncpy(Gdata,buff+4,1);//取得传送来的4位16进制;
		    delete[] buff;
		    if(((int)*Gdata)<0)
			    return(256+(int)*Gdata);
		    else		
                return(int)*Gdata;
		}
		else
			return 0;
}

BOOL CSerial::TramFile()
{   
	char szMessage[8]="CWJOK\0";
//	CString Msg;
	//TCHAR buff[50];
    char buff[51];
	int nBytesSent;
	HANDLE hFile;
//	sprintf(szMessage,"CWJOK", address);
///读文件
    DWORD  dwBytesTOR;
	dwBytesTOR=GetFileSize(TEXT("Data.txt"),NULL);
    hFile = CreateFile (TEXT("Data.txt"),      // Open One.txt.
                      GENERIC_READ|GENERIC_WRITE,           // Open for reading
                      0,                      // Do not share
                      NULL,                   // No security
                      OPEN_EXISTING,//CREATE_NEW,          // Existing file only
                      FILE_ATTRIBUTE_NORMAL,  // Normal file
                      NULL); 

    DWORD  dwBytesRead;
	BOOL bRc;
    CString temp;
	if (hFile == INVALID_HANDLE_VALUE)
	{
    // Your error-handling code goes here.
	strncpy(szMessage,"ERROR!\0",7); 
    nBytesSent=SendData(szMessage,strlen(szMessage));
    return FALSE;
	} 

	nBytesSent=SendData(szMessage,strlen(szMessage));//通知PC开始接收
    Sleep(1000);
	//////////////////////////一次读写50字节
	USES_CONVERSION;
	for(int i=0;i<100;i++)
	{
    bRc = ReadFile(hFile,buff,50, &dwBytesRead, NULL);
	SendData(buff,50);
    Sleep(300);
	}
   // Msg.Format(_T("BBBBBB")); 
	strncpy(szMessage,"BBBBBBBB",8); 
    nBytesSent=SendData(szMessage,strlen(szMessage));
    //SendData(Msg);
	Sleep(500);
	//strncpy(szMessage,"Transmission Over!",8);
    SendData(szMessage,strlen(szMessage));
	CloseHandle(hFile);
	return TRUE;
}

int CSerial::NReadData(char *data)
{
	DWORD dwBytesTransferred;
	Sleep(100);
//	while(m_hIDComDev!= INVALID_HANDLE_VALUE)
   {
				ReadFile (m_hIDComDev,
					data, 
					50, 
					&dwBytesTransferred,
					0
					);
     if(dwBytesTransferred>0&&dwBytesTransferred<=50)
	 {
     data[dwBytesTransferred]='\0'; 
	 }
	} 
	return dwBytesTransferred;
}