vcsampledlg.cpp

modbus通讯

	break;
case 5:
	m_cmbVerftyCode.EnableWindow(false);
	m_cmbVerftyCode.ShowWindow(SW_HIDE);		

	tVergtyCode =(CStatic *) GetDlgItem(IDC_stVertfyCode);
	tVergtyCode->ShowWindow(SW_HIDE);

	m_edValue.EnableWindow(true);
	m_edStartAddr.EnableWindow(true);

	m_edNum.EnableWindow(true);
	m_cmbItem.EnableWindow(true);
	m_cmbSationNo.EnableWindow(true);
	m_btnOperation.SetWindowText("写入");
	break;
case 6:
	m_cmbVerftyCode.EnableWindow(true);
	m_cmbVerftyCode.ShowWindow(SW_SHOWNORMAL);		

	tVergtyCode =(CStatic *) GetDlgItem(IDC_stVertfyCode);
	tVergtyCode->ShowWindow(SW_SHOWNORMAL);

	m_edValue.EnableWindow(false);
	m_edStartAddr.EnableWindow(false);
	m_edNum.EnableWindow(false);
	m_cmbItem.EnableWindow(false);
	m_cmbSationNo.EnableWindow(true);
	m_btnOperation.SetWindowText("回送");
	break;
default:
	break;
	}
}
/*
*	实现不同读、写函数
*/
void CVcSampleDlg::OnOpertionBtn() 
{
	// TODO: Add your control notification handler code here

	int nResult=0;//函数返回结果
	int nStatioNo=0;//站点号
	int nNum=0;//元件个数
	unsigned char *pChValue=NULL;//元件值  
	unsigned char *pDelValue=NULL;
	short sRefValue[]={0};//元件返回值
	char  ucValue[1]={0};//元件值
	short stDataField[2]={0};//诊断校验的结果
	short * psValue=NULL;	
	short * psDelValue=NULL;
	unsigned char ucRefValue[]={0};
	int nValue;//元件值  
	int nLen;
	double  dSpitTimes;
	int  nSpitTimes;
	CString strSpilt;
	int nVeritfyCode=0;//诊断码
	BOOL bReturn=false;//判断是否需要换行
	char * pStartAddr=NULL;
	CString strValue;
	CString strItem;
	CString strStartAddr;
	CString strNum;
	CString msg,oldMsg;
	CString strVerifyCode;
	CString strMsg,reviceMsg;
	int nSpint=0;
	//获取站点号begin
	m_cmbSationNo.GetWindowText(strValue);
	nStatioNo=atoi(strValue);
	//获取站点号end
	//获取元件类型begin
	m_cmbItem.GetWindowText(strItem);
	//获取元件类型end
	//获取元件的起始地址 begin
	if(m_edStartAddr.IsWindowEnabled())
	{		
		m_edStartAddr.GetWindowText(strStartAddr);
		if(strStartAddr=="")
		{
			MessageBox("起始地址不能为空，请输入!","提示框",MB_ICONQUESTION);
			m_edStartAddr.SetFocus();
			return ;
		}	
		if((strItem=="X")||(strItem=="Y"))
		{
			if ((strStartAddr=="9")||(strStartAddr=="8")||(strStartAddr.Find("9",0)>0)||(strStartAddr.Find("8",0)>0))
			{

				MessageBox("八进制不能输入'9'或'8'，请输入!","提示框",MB_ICONQUESTION);
				m_edStartAddr.SetFocus();
				return ;
			}
			/*sscanf(strStartAddr,"%d",&nValue); 
			if(nValue > 256) 
			{
				MessageBox("起始地址不能大于256，请输入!","提示框",MB_ICONQUESTION);
				m_edStartAddr.SetFocus();
				return ;
			}*/
			if(nNum >256)
			{
				MessageBox("元件值个数不能超过256，请输入!","提示框",MB_ICONQUESTION);
				m_edNum.SetFocus();
				return ;
			}
			strItem=strItem+strStartAddr;	
			m_pStartaddr=new char[strlen(strItem)+1];
			strncpy(m_pStartaddr,strItem,strlen(strItem));
			m_pStartaddr[strlen(strItem)]='\0';	
		}
	}
	//获取元件的起始地址 begin
	//获取元件的个数 begin
	if(m_edNum.IsWindowEnabled())
	{
		m_edNum.GetWindowText(strNum);
		if(strNum=="")
		{
			MessageBox("元件个数不能为空，请输入!","提示框",MB_ICONQUESTION);
			m_edNum.SetFocus();
			return ;
		}
		nNum=atoi(strNum);
	}
	//获取元件的个数 end

	ReaddMultiBit rdBit=NULL;//读多个线圈的函数指针
	ReaddMultiWord rdWord=NULL;//读多个寄存器的函数指针
	ACKPack        ackReport=NULL;//回送诊断校验的函数指针
	WrtOneBit    wrOneBit=NULL;//写单个线圈函数指针
	WrtMultBit wrMultBit=NULL;//写多个线圈的函数指针
	WrtOneWord wrOneWord=NULL;//写单个寄存器的函数指针
	WrtMultWord wrMultWord=NULL;//写多个寄存器的函数指针
	//判断获取Dll的句柄是否为空
	if(m_hInst)
	{
		switch(m_nOperIndex) {
case 0:
	if (m_bListen)
	{
		MessageBox("从机进入LISTEN ONLY 模式,重新启动通信选项命令(0x01)","提示框",MB_ICONQUESTION);
		return;
	}

	//获取读多个线圈的函数指针
	rdBit=(ReaddMultiBit)::GetProcAddress(m_hInst,"RdMultiBit");
	if(rdBit)
	{
		//调用Dll读多个线圈的函数
		pChValue=new unsigned char[nNum];
		pDelValue= pChValue;
		nResult=rdBit(m_nCommName,nStatioNo,m_pStartaddr,nNum,pChValue);
		if(nResult !=0)
		{
			m_EdMsg.GetWindowText(oldMsg);
			msg.Format("\r\n通过COM%d 读多个线圈失败,错误代码:%d,错误消息:%s.%s",m_nCommName,nResult,getAckMsg(nResult),oldMsg);
			m_EdMsg.SetWindowText(msg);
			if (pChValue!=NULL)
			{
				delete [] pChValue;
				pChValue=NULL;
			}
			if(m_pStartaddr!=NULL)
			{
				delete [] m_pStartaddr;
				m_pStartaddr=NULL;
			}
			return ;
		}
		//获取接收到消息内容 begin
		for(int k=0;k<nNum;k++)
		{
			if (k>0)
			{

				if(k%15 == RESIDUE_NUM)
				{
					reviceMsg.Format("%s%d\r\n",strMsg,*pChValue++);
				}
				else
				{					
					reviceMsg.Format("%s%d",strMsg,*pChValue++);
				}
			}else
			{
				reviceMsg.Format("%s%d",strMsg,*pChValue++);
			}
			if(k < nNum-1)
			{						
				strMsg =reviceMsg+"、";
			}
			else
			{
				strMsg =reviceMsg;
			}
		}
		//获取接收到消息内容 end;  
		m_EdMsg.GetWindowText(oldMsg);
		msg.Format("\r\n通过COM%d 读多个线圈成功!消息内容:\r\n%s.%s",m_nCommName,strMsg,oldMsg);
		m_EdMsg.SetWindowText(msg);
		if (pDelValue!=NULL)
		{
			delete [] pDelValue;
			pDelValue=NULL;
		}
	}		    
	break;
case 1:
	if (m_bListen)
	{
		MessageBox("从机进入LISTEN ONLY 模式,重新启动通信选项命令(0x01)","提示框",MB_ICONQUESTION);
		return;
	}
	//获取读多个寄存器的函数指针
	rdWord=(ReaddMultiWord)::GetProcAddress(m_hInst,"RdMultiWord");
	if(rdWord)
	{
		//调用DLL读多个寄存器的函数指针
		psValue =new short[nNum];
		psDelValue=psValue;
		nResult=rdWord(m_nCommName,nStatioNo,m_pStartaddr,nNum,psValue);
		if(nResult !=0)
		{
			m_EdMsg.GetWindowText(oldMsg);
			msg.Format("\r\n通过COM%d 读多个寄存器失败,错误代码:%d,错误消息:%s.%s",m_nCommName,nResult,getAckMsg(nResult),oldMsg);
			m_EdMsg.SetWindowText(msg);
			if(psValue!=NULL)
			{
				delete [] psValue;
				psValue=NULL;
			}
			if(m_pStartaddr!=NULL)
			{
				delete [] m_pStartaddr;
				m_pStartaddr=NULL;
			}
			return ;
		}
		//获取接收到消息内容 begin
		for(int k=0;k<nNum;k++)
		{
			if (k>0)
			{

				if(k%15 == RESIDUE_NUM)
				{
					reviceMsg.Format("%s%x\r\n",strMsg,(unsigned short)*psValue++);
				}
				else
				{					
					reviceMsg.Format("%s%x",strMsg,(unsigned short)*psValue++);
				}
			}else
			{
				reviceMsg.Format("%s%x",strMsg,(unsigned short)*psValue++);
			}


			if(k < nNum-1)
			{						
				strMsg =reviceMsg+"、";
			}
			else
			{
				strMsg =reviceMsg;
			}
		}
		//获取接收到消息内容 end;  
		m_EdMsg.GetWindowText(oldMsg);
		msg.Format("\r\n通过COM%d 读多个寄存器成功,消息内容:\r\n%s.%s",m_nCommName,strMsg,oldMsg);
		m_EdMsg.SetWindowText(msg);
		if(psDelValue!=NULL)
		{
			delete [] psDelValue;
			psDelValue=NULL;
		}
	}		  
	break;
case 2:
	if (m_bListen)
	{
		MessageBox("从机进入LISTEN ONLY 模式,重新启动通信选项命令(0x01)","提示框",MB_ICONQUESTION);
		return;
	}
	if(m_edValue.IsWindowEnabled())
	{				
		m_edValue.GetWindowText(strValue);//获取元件的值
		if(strValue=="")
		{
			MessageBox("元件值不能为空，请输入!","提示框",MB_ICONQUESTION);
			m_edValue.SetFocus();
			return ;
		}
		sscanf(strValue,"%x",&nValue); //转换为十六进制
	}
	if(nValue > 65535) //判断是否超过255
	{
		MessageBox("元件值超过unsinged short取值范围(0-65535)，请重新输入!","提示框",MB_ICONQUESTION);
		return;
	}
	//获取写单个线圈函数指针
	wrOneBit=(WrtOneBit)::GetProcAddress(m_hInst,"WrtOneBit");
	if(wrOneBit)				 
	{
		//调用Dll写单个线圈函数
		nResult=wrOneBit(m_nCommName,nStatioNo,m_pStartaddr,nValue);
		strValue="元件值:"+strValue;
		if(nResult !=0)
		{
			m_EdMsg.GetWindowText(oldMsg);
			msg.Format("\r\n%s.通过COM%d 写单个线圈失败,错误代码:%d,错误消息:%s.%s",strValue,m_nCommName,nResult,getAckMsg(nResult),oldMsg);
			m_EdMsg.SetWindowText(msg);
			if(m_pStartaddr!=NULL)
			{
				delete [] m_pStartaddr;
				m_pStartaddr=NULL;
			}
			return ;
		}
		m_EdMsg.GetWindowText(oldMsg);
		msg.Format("\r\n%s.通过COM%d 写单个线圈成功.%s",strValue,m_nCommName,oldMsg);
		m_EdMsg.SetWindowText(msg);	
	}
	break;
case 3:
	if (m_bListen)
	{
		MessageBox("从机进入LISTEN ONLY 模式,重新启动通信选项命令(0x01)","提示框",MB_ICONQUESTION);
		return;
	}
	if(m_edValue.IsWindowEnabled())
	{				
		m_edValue.GetWindowText(strValue);//获取元件的值
		if(strValue=="")
		{
			MessageBox("元件值不能为空，请输入!","提示框",MB_ICONQUESTION);
			m_edValue.SetFocus();
			return ;
		}
		//拆分元件的值
		nSpint=SpiltChar(strValue,nNum);
		if(GREAT_VALUE==nSpint)
		{
			MessageBox("元件值个数与元件个数不相等，请输入!","提示框",MB_ICONQUESTION); 
			m_edValue.SetFocus();
			return ;
		}
		else
		{				
			if(GREAT_NUM==nSpint)
			{					
				return ;
			}
		}
	}
	//获取写多个线圈函数指针
	wrMultBit=(WrtMultBit)::GetProcAddress(m_hInst,"WrtMultiBit");
	if(wrMultBit)				 
	{
		//调用Dll写多个线圈函数
		nResult=wrMultBit(m_nCommName,nStatioNo,m_pStartaddr,nNum,m_chBitValue);
		nLen=strValue.GetLength();
		dSpitTimes=strValue.GetLength();
		dSpitTimes=ceil(dSpitTimes/48);
		nSpitTimes=(int) dSpitTimes;  
		for(int n=0;n<nSpitTimes;n++)
		{
			if(n==nSpitTimes-1)
			{
				reviceMsg=strValue.Left(strValue.GetLength());
				strSpilt.Format("%s%s",strMsg,reviceMsg);
				strMsg=strSpilt;
			}
			else
			{						
				reviceMsg=strValue.Left(48);
				strSpilt.Format("%s%s\r\n",strMsg,reviceMsg);
				strMsg=strSpilt;
				strValue=strValue.Mid(48,strValue.GetLength());
			}
		}
		strMsg="元件值："+strMsg;
		if(nResult !=0)
		{
			m_EdMsg.GetWindowText(oldMsg);
			msg.Format("\r\n%s.\r\n通过COM%d 写多个线圈失败,错误代码:%d,错误消息:%s.%s",strMsg,m_nCommName,nResult,getAckMsg(nResult),oldMsg);
			m_EdMsg.SetWindowText(msg);
			if(m_pStartaddr!=NULL)
			{
				delete [] m_pStartaddr;
				m_pStartaddr=NULL;
			}
			return ;
		}
		m_EdMsg.GetWindowText(oldMsg);
		msg.Format("\r\n%s.\r\n通过COM%d 写多个线圈成功.%s",strMsg,m_nCommName,oldMsg);
		m_EdMsg.SetWindowText(msg);
	}
	break;
case 4:
	if (m_bListen)
	{
		MessageBox("从机进入LISTEN ONLY 模式,重新启动通信选项命令(0x01)","提示框",MB_ICONQUESTION);
		return;
	}
	if(m_edValue.IsWindowEnabled())
	{				
		m_edValue.GetWindowText(strValue);//获取元件的值
		if(strValue=="")
		{
			MessageBox("元件值不能为空，请输入!","提示框",MB_ICONQUESTION);
			m_edValue.SetFocus();
			return ;
		}
		sscanf(strValue,"%x",&nValue); //转换为十六进制
	}
	if(nValue > 65535) //判断是否超过255
	{
		MessageBox("元件值超过unsinged short取值范围(0-65535)，请重新输入!","提示框",MB_ICONQUESTION);
		return;
	}
	//获取写单个寄存器函数指针
	wrOneWord=(WrtOneWord)::GetProcAddress(m_hInst,"WrtOneWord");
	if(wrOneWord)				 
	{
		//调用DLL写单个寄存器函数指针
		nResult=wrOneWord(m_nCommName,nStatioNo,m_pStartaddr,nValue);
		strValue="元件值:"+strValue;
		if(nResult !=0)
		{
			m_EdMsg.GetWindowText(oldMsg);
			msg.Format("\r\n%s.通过COM%d 写单个寄存器失败，错误代码：%d,错误消息:%s.%s",strValue,m_nCommName,nResult,getAckMsg(nResult),oldMsg);
			m_EdMsg.SetWindowText(msg);
			if(m_pStartaddr!=NULL)
			{
				delete [] m_pStartaddr;
				m_pStartaddr=NULL;
			}
			return ;
		}
		m_EdMsg.GetWindowText(oldMsg);
		msg.Format("\r\n%s.通过COM%d 写单个寄存器成功.%s",strValue,m_nCommName,oldMsg);
		m_EdMsg.SetWindowText(msg);
	}
	break;
case 5:
	if (m_bListen)
	{
		MessageBox("从机进入LISTEN ONLY 模式,重新启动通信选项命令(0x01)","提示框",MB_ICONQUESTION);
		return;
	}
	if(m_edValue.IsWindowEnabled())
	{				
		m_edValue.GetWindowText(strValue);//获取元件的值
		if(strValue=="")
		{
			MessageBox("元件值不能为空，请输入!","提示框",MB_ICONQUESTION);
			m_edValue.SetFocus();
			return ;
		}
		nSpint=SpiltString(strValue,nNum);
		if(GREAT_VALUE==nSpint) //拆分元件的值
		{
			MessageBox("元件值个数与元件个数不相等，请输入!","提示框",MB_ICONQUESTION);     
			m_edValue.SetFocus();
			return;
		}else  if (GREAT_NUM==nSpint)
		{
			return ;
		}
	}
	//获取写多个寄存器函数指针
	wrMultWord=(WrtMultWord)::GetProcAddress(m_hInst,"WrtMultiWord");
	if(wrMultWord)				 
	{
		//调用DLL写多个寄存器函数指针
		nResult=wrMultWord(m_nCommName,nStatioNo,m_pStartaddr,nNum,m_shWordValue);
		nLen=strValue.GetLength();
		dSpitTimes=strValue.GetLength();
		dSpitTimes=ceil(dSpitTimes/48);
		nSpitTimes=(int) dSpitTimes;  
		for(int n=0;n<nSpitTimes;n++)
		{
			if(n==nSpitTimes-1)
			{
				strValue=strValue.Left(strValue.GetLength());
				strSpilt.Format("%s%s",strMsg,strValue);
				strMsg=strSpilt;
			}
			else
			{						
				strValue=strValue.Left(48);
				strSpilt.Format("%s%s\r\n",strMsg,strValue);
				strMsg=strSpilt;
			}
		}
		strMsg="元件值："+strMsg;
		if(nResult !=0)
		{
			m_EdMsg.GetWindowText(oldMsg);
			msg.Format("\r\n%s.\r\n通过COM%d 写多个寄存器失败,错误代码:%d,错误消息:%s.%s",strMsg,m_nCommName,nResult,getAckMsg(nResult),oldMsg);
			m_EdMsg.SetWindowText(msg);
			if(m_pStartaddr!=NULL)
			{
				delete [] m_pStartaddr;
				m_pStartaddr=NULL;
			}
			return ;
		}
		m_EdMsg.GetWindowText(oldMsg);
		msg.Format("\r\n%s.\r\n通过COM%d 写多个寄存器成功.%s",strMsg,m_nCommName,oldMsg);
		m_EdMsg.SetWindowText(msg);
	}
	break;