modbus.java

工控modbus协议通讯

//
//Modbus class to ccomunicate with modbus server 
//
package FreeModbus.Util;

import java.io.*;
import java.net.*;
import java.lang.Exception;
import FreeModbus.Util.ModbusException;



public  class Modbus 

{
	
	private Socket m_connection;
	private DataInputStream m_istream; //input buffer 
	private DataOutputStream m_ostream; //output buffer 
	private final int OUTPUT_BUFFER_SIZE=512; 
	private int m_iTimeOut=10000;      //Max Time out
	private boolean m_bIsConnected=false;
	private boolean m_bReConnectOnEveryMessage=false;
	private int m_iRetries=1;
	private boolean m_bThrowCommException=false;

	//internet frame 
	private final int MBAP_HEADER_SIZE=6;
	private final int OFFSET_MODBUS_MESS=6;

	//Modbus Functions 
	private static final  byte READ_OUTPUT_REGISTERS=3; 
	private static final  byte READ_INPUT_REGISTERS=4;
	private static final byte READ_OUTPUT_STATUS=1;
	private static final byte READ_INPUT_STATUS=2;
	private static final byte PRESET_MULTIPLE_REGISTERS=16;
	private static final byte PRESET_SINGLE_REGISTER=6;
	private static final byte LOOP_BACK_TEST=8;
	private static final byte FORCE_SINGLE_COIL=5;
	private static final byte FORCE_MULTIPLE_COILS=15;
	
	//Errors 
	
	public static final short  ERR_OK = 0; //No Error
	public static final short  ERR_TIMEOUT = 1;
	public static final short  ERR_EXECPTION=9000;
	public static final short  ERR_INVALID_RESPONSE=12;
	public static final short  ERR_MODBUS_EXCPTION=8000; //Excption 1->8001 , 2->8002...
    
	//General Constants 
	
	public static final int REAL_NORMAL=0;
    public static final int REAL_REVERSE=1;
	
	/*  TCP/IP settings. */
	private String m_sAddress="127.0.0.1"; //
	private int m_iPort=502;
	
	
		
	//constructor
	public Modbus(){
		m_iRetries=1;
	}
	

	public int Retries() {

		return m_iRetries;
	}

	public void Retries(int iRetries) {

		m_iRetries=iRetries;
	}

	public boolean ThrowCommException() {
		return m_bThrowCommException;
	}
	
	public void ThrowCommException(boolean bThrow) {
		m_bThrowCommException = bThrow;
	}

	
	public String ErrorMessage(int iErrorNumber) {
		String sMsg="";

		sMsg = sMsg + " #" + iErrorNumber;
		return sMsg;
	}

	private void ThrowException (int iNumber) {
		
		if (m_bThrowCommException && (iNumber!=ERR_OK)) {
			throw  new ModbusException(ErrorMessage(iNumber), iNumber);			
		}
	}

	public boolean ReConnectOnEveryMessage() {

		return m_bReConnectOnEveryMessage;
	}



	public void ReConnectOnEveryMessage(boolean bReConnectOnEveryMessage) {

		m_bReConnectOnEveryMessage=bReConnectOnEveryMessage;

	}

    public void Host(String sHost) {
		
        m_sAddress = sHost;
	}

	public String Host() {
		
        return m_sAddress;
	}

	public int Port() {

       return m_iPort;
	}

	public void Port(int iPort) {

      m_iPort = iPort;
	}

	// Method to close the network connection.
	public void closeConnection()
	{
		try {
			m_istream.close();
			m_ostream.close();
			m_connection.close();
			m_bIsConnected=false;
		}
		catch(IOException e) { 
			System.err.println("Connection close with Modbus server failed.");
		}
	} // End closeConnection().
	
	
	// Method for connecting to the Modbus Server. 
	public boolean openConnection(String host, int port, int iTimeOut)
	{

		if (IsConnected()) {
			closeConnection();
		}

		try
		{
			m_sAddress=host;
			m_iPort=port;
			m_iTimeOut=iTimeOut;

			m_connection = new Socket(host, port);
			

			//Input buffer 
			m_istream = new DataInputStream(new
				BufferedInputStream(m_connection.getInputStream()));
			
			//output buffer 
			m_ostream = new DataOutputStream(new
				BufferedOutputStream(m_connection.getOutputStream(),OUTPUT_BUFFER_SIZE));
			
			m_iTimeOut=iTimeOut;
			m_bIsConnected=true;
			return(true);
		}
		catch (IOException e) {
			System.err.println("Could not open connection to Modbus server.");
			m_bIsConnected=false;
			return(false);
		}
	}//end open connection 
	
	public boolean IsConnected(){
		return(m_bIsConnected);
	}
	
	public  short ReadOutputRegisters(short nAddr,  int nDataStart , short nQtd , short anRegValues[]) {
		
		short QUERY_LENGHT=6;
		byte abyQuery[]= new byte[QUERY_LENGHT+MBAP_HEADER_SIZE];
		short nReplyLength=(short)(3 + 2 * nQtd);
		int  aiReply[]  = new int[nReplyLength+MBAP_HEADER_SIZE];
		short nError;
		short nByte;
		short nRespByte;
		int iRetry;
			
		//Query 
		InsertMBAPHeader(abyQuery ,QUERY_LENGHT);
		
		//modbus message 
		abyQuery[OFFSET_MODBUS_MESS+0]=(byte)nAddr; //ADDR	
		abyQuery[OFFSET_MODBUS_MESS+1]=READ_OUTPUT_REGISTERS; //Function 
		abyQuery[OFFSET_MODBUS_MESS+2]=HiByte(nDataStart);
		abyQuery[OFFSET_MODBUS_MESS+3]=LoByte(nDataStart);
		abyQuery[OFFSET_MODBUS_MESS+4]=HiByte(nQtd);
		abyQuery[OFFSET_MODBUS_MESS+5]=LoByte(nQtd);
		

		iRetry=0;
		
		do {
			
			nError=TxRxMessage(abyQuery,(short)(QUERY_LENGHT+MBAP_HEADER_SIZE),aiReply, nReplyLength);
			
			if (nError==ERR_OK) {
				if (((byte)aiReply[0]!=abyQuery[OFFSET_MODBUS_MESS+0])||((byte)aiReply[1]!=abyQuery[OFFSET_MODBUS_MESS+1])) {
					nError=ERR_INVALID_RESPONSE;
				}
				else {
					nByte=0;//return array 
					for(nRespByte=3;nRespByte<nReplyLength;nRespByte=(short)(nRespByte+2)){
						anRegValues[nByte] = (short)(aiReply[nRespByte]);
						anRegValues[nByte]=(short)((anRegValues[nByte]<<8)|(aiReply[nRespByte+1]));
						nByte++;
					}
					
				}
				
				
			}//nerror=ERR_OK
			iRetry++;
			
		} while ((iRetry<m_iRetries)&&(nError!=ERR_OK));

		ThrowException(nError);

		return(nError);
		
	}//end ReadOutRegisters 
	
	
	public  short ReadOutputRegisters(short nAddr,  int nDataStart , short nQtd , int aiRegValues[]) {
		
		
		short anRegValues[];
		short nError ;
		
		anRegValues=new short[aiRegValues.length];
		nError = ReadOutputRegisters(nAddr,nDataStart ,nQtd ,anRegValues);
		ShortToIntArray(anRegValues,aiRegValues);
		return nError;
		
		
	}

	public short ReadOutputRegisters(short nAddr,  int nDataStart , short nQtd , float afRegValues[], int nRealType ) {
	
		
	 short anValues[];
	 short nError;

	 anValues = new short[2*afRegValues.length];
	 
	 nError =ReadOutputRegisters(nAddr,nDataStart,(short)(2*nQtd),anValues);
	 ShortToFloatArray(anValues,afRegValues,nRealType);
	
	 return nError;
	
	}

	public short ReadOutputRegisters(short nAddr,  int nDataStart , short nQtd , double adRegValues[], int nRealType ) {
	
		
	 short anValues[];
	 short nError;

	 anValues = new short[4*adRegValues.length];
	 
	 nError =ReadOutputRegisters(nAddr,nDataStart,(short)(4*nQtd),anValues);
	 ShortToDoubleArray(anValues,adRegValues,nRealType);
	 return nError;
	
	}
	
	
	public short ReadInputRegisters(short nAddr,  int nDataStart , short nQtd , short anRegValues[]) {
		
		byte abyQuery[]= new byte[6+MBAP_HEADER_SIZE];
		short nReplyLength=(short)(3 + 2 * nQtd);
		int  aiReply[]  = new int[nReplyLength+MBAP_HEADER_SIZE];
		short nError;
		short nByte;
		short nRespByte;
		short QUERY_LENGHT=6;
		int iRetry;
		
		
		//Query 
		InsertMBAPHeader(abyQuery,QUERY_LENGHT);
		
		//modbus message 
		abyQuery[OFFSET_MODBUS_MESS+0]=(byte)nAddr; //ADDR	
		abyQuery[OFFSET_MODBUS_MESS+1]=READ_INPUT_REGISTERS; //Function 
		abyQuery[OFFSET_MODBUS_MESS+2]=HiByte(nDataStart);
		abyQuery[OFFSET_MODBUS_MESS+3]=LoByte(nDataStart);
		abyQuery[OFFSET_MODBUS_MESS+4]=HiByte(nQtd);
		abyQuery[OFFSET_MODBUS_MESS+5]=LoByte(nQtd);
		

		iRetry=0;
		
		do {
			
			nError=TxRxMessage(abyQuery,(short)(6+MBAP_HEADER_SIZE),aiReply, nReplyLength);
			
			if (nError==ERR_OK) {
				if (((byte)aiReply[0]!=abyQuery[OFFSET_MODBUS_MESS+0])||((byte)aiReply[1]!=abyQuery[OFFSET_MODBUS_MESS+1])) {
					nError=ERR_INVALID_RESPONSE;
				}
				else {
					nByte=0;//return array 
					for(nRespByte=3;nRespByte<nReplyLength;nRespByte=(short)(nRespByte+2)){
						anRegValues[nByte] = (short)(aiReply[nRespByte]);
						anRegValues[nByte]=(short)((anRegValues[nByte]<<8)|(aiReply[nRespByte+1]));
						nByte++;
					}
					
				}
				
				
			}//nerror=ERR_OK
			
			iRetry++;

		} while ((iRetry<m_iRetries)&&(nError!=ERR_OK));

		ThrowException(nError);

		return(nError);
		
	}//end ReadInputRegisters 
	
	
	public short ReadInputRegisters(short nAddr,  int nDataStart , short nQtd , int aiRegValues[]) {
		
		
		short anRegValues[];
		short nError ;
		
		anRegValues=new short[aiRegValues.length];
		nError = ReadInputRegisters(nAddr,nDataStart ,nQtd ,anRegValues);
		ShortToIntArray(anRegValues,aiRegValues);
		return nError;
		
		
	}

	public short ReadInputRegisters(short nAddr,  int nDataStart , short nQtd , float afRegValues[], int nRealType ) {
	
		
	 short anValues[];
	 short nError;

	 anValues = new short[2*afRegValues.length];
	 
	 nError =ReadInputRegisters(nAddr,nDataStart,(short)(2*nQtd),anValues);
	 ShortToFloatArray(anValues,afRegValues,nRealType);
	
	 return nError;
	
	}

	public short ReadInputRegisters(short nAddr,  int nDataStart , short nQtd , double adRegValues[], int nRealType ) {
	
		
	 short anValues[];
	 short nError;

	 anValues = new short[4*adRegValues.length];
	 
	 nError =ReadInputRegisters(nAddr,nDataStart,(short)(4*nQtd),anValues);
	 ShortToDoubleArray(anValues,adRegValues,nRealType);
	 return nError;
	
	}
	
	public short ReadOutputStatus(short nAddr,  int nDataStart , short nQtd , boolean abCoilValues[]) {
		
		short QUERY_LENGHT=6;
		
		byte abyQuery[]= new byte[QUERY_LENGHT+MBAP_HEADER_SIZE];
		short nReplyLength=(short)(3 + (nQtd + 7) / 8);
		int  aiReply[]  = new int[nReplyLength+MBAP_HEADER_SIZE];
		short nError;
		short nRespByte;
		int iCoil;
		int iBit;
		int iRetry;
		
		
		//Query 
		InsertMBAPHeader(abyQuery,QUERY_LENGHT);
		
		//modbus message 
		abyQuery[OFFSET_MODBUS_MESS+0]=(byte)nAddr; //ADDR	
		abyQuery[OFFSET_MODBUS_MESS+1]=READ_OUTPUT_STATUS; //Function 
		abyQuery[OFFSET_MODBUS_MESS+2]=HiByte(nDataStart);
		abyQuery[OFFSET_MODBUS_MESS+3]=LoByte(nDataStart);
		abyQuery[OFFSET_MODBUS_MESS+4]=HiByte(nQtd);
		abyQuery[OFFSET_MODBUS_MESS+5]=LoByte(nQtd);

		
		iRetry=0;
		
		do {
			
			nError=TxRxMessage(abyQuery,(short)(QUERY_LENGHT+MBAP_HEADER_SIZE),aiReply, nReplyLength);
			
			if (nError==ERR_OK) {
				if (((byte)aiReply[0]!=abyQuery[OFFSET_MODBUS_MESS+0])||((byte)aiReply[1]!=abyQuery[OFFSET_MODBUS_MESS+1])) {
					nError=ERR_INVALID_RESPONSE;
				}
				else {
					iBit=0;
					nRespByte=3;		
					for(iCoil=0;iCoil<nQtd;iCoil++){
						
						if (iBit>7){
							iBit=0;
							nRespByte++;
						}
						
						if ((aiReply[nRespByte] & (0x01<<iBit))>0){
							abCoilValues[iCoil]= true; 
						}
						else {
							abCoilValues[iCoil]= false; 
						}
						iBit++; //next bit 
						
					}// end for 
					
				}// else 
				
				
			}//nerror=ERR_OK
			iRetry++;
			
		} while ((iRetry<m_iRetries)&&(nError!=ERR_OK));

		ThrowException(nError);

		return(nError);
		
	}//end ReadOutStatus 
	
	
	public short ReadInputStatus(short nAddr,  int nDataStart , short nQtd , boolean abCoilValues[]) {
		
		short QUERY_LENGHT=6;
		
		byte abyQuery[]= new byte[QUERY_LENGHT+MBAP_HEADER_SIZE];
		short nReplyLength=(short)(3 + (nQtd + 7) / 8);
		int  aiReply[]  = new int[nReplyLength+MBAP_HEADER_SIZE];
		short nError;
		short nRespByte;
		int iCoil;
		int iBit;
		int iRetry;
		
		
		//Query 
		InsertMBAPHeader(abyQuery,QUERY_LENGHT);


		//modbus message 
		abyQuery[OFFSET_MODBUS_MESS+0]=(byte)nAddr; //ADDR	
		abyQuery[OFFSET_MODBUS_MESS+1]=READ_INPUT_STATUS; //Function 
		abyQuery[OFFSET_MODBUS_MESS+2]=HiByte(nDataStart);
		abyQuery[OFFSET_MODBUS_MESS+3]=LoByte(nDataStart);
		abyQuery[OFFSET_MODBUS_MESS+4]=HiByte(nQtd);
		abyQuery[OFFSET_MODBUS_MESS+5]=LoByte(nQtd);
		

		iRetry=0;
		
		do {
			
			nError=TxRxMessage(abyQuery,(short)(QUERY_LENGHT+MBAP_HEADER_SIZE),aiReply, nReplyLength);
			
			if (nError==ERR_OK) {
				if (((byte)aiReply[0]!=abyQuery[OFFSET_MODBUS_MESS+0])||((byte)aiReply[1]!=abyQuery[OFFSET_MODBUS_MESS+1])) {
					nError=ERR_INVALID_RESPONSE;
				}
				else {
					iBit=0;
					nRespByte=3;		
					for(iCoil=0;iCoil<nQtd;iCoil++){
						
						if (iBit>7){
							iBit=0;
							nRespByte++;
						}
						
						if ((aiReply[nRespByte] & (0x01<<iBit))>0){
							abCoilValues[iCoil]= true; 
						}
						else {
							abCoilValues[iCoil]= false; 
						}
						iBit++; //next bit 
						
					}// end for 
					
				}// else 
				
				
			}//nerror=ERR_OK
			iRetry++;
			
		} while ((iRetry<m_iRetries)&&(nError!=ERR_OK));

		ThrowException(nError);
		
		return(nError);
		
	}//end ReadOutStatus 
	
	
	
	public short PresetMultipleRegisters(short nAddr,  int nDataStart , short nQtd , short anRegValues[]) {
		
		
		short QUERY_LENGHT=(short)(7+2*nQtd);
		byte abyQuery[]= new byte[QUERY_LENGHT+MBAP_HEADER_SIZE];
		short nReplyLength=(short)(6);
		int  aiReply[]  = new int[nReplyLength];
		short nError;
		short nByte;
		short nRespByte;
		int	  iReg; 	
		
		int iRetry;
		
		
		//Query 
		InsertMBAPHeader(abyQuery,QUERY_LENGHT);
				
		//modbus message 
		abyQuery[OFFSET_MODBUS_MESS+0]=(byte)nAddr; //ADDR	
		abyQuery[OFFSET_MODBUS_MESS+1]=PRESET_MULTIPLE_REGISTERS; //Function 
		abyQuery[OFFSET_MODBUS_MESS+2]=HiByte(nDataStart);
		abyQuery[OFFSET_MODBUS_MESS+3]=LoByte(nDataStart);
		abyQuery[OFFSET_MODBUS_MESS+4]=HiByte(nQtd);
		abyQuery[OFFSET_MODBUS_MESS+5]=LoByte(nQtd);
		abyQuery[OFFSET_MODBUS_MESS+6]=(byte)(2*nQtd);
		
		for (iReg=0;iReg<(nQtd);iReg++){
			abyQuery[OFFSET_MODBUS_MESS+7+iReg*2]=HiByte(anRegValues[iReg]);
			abyQuery[OFFSET_MODBUS_MESS+7+iReg*2+1]=LoByte(anRegValues[iReg]);
		}
		
		
		iRetry=0;

		do {

			nError=TxRxMessage(abyQuery,(short)(QUERY_LENGHT+MBAP_HEADER_SIZE),aiReply,nReplyLength);
			
			
			if (nError==ERR_OK) {
				
				for (iReg=0;iReg<6;iReg++){
					if ((byte)aiReply[iReg]!=abyQuery[OFFSET_MODBUS_MESS+iReg]) {
						nError=ERR_INVALID_RESPONSE;
						break;
					}
				}
				
			}//nerror=ERR_OK

			iRetry++;
			
		} while ((iRetry<m_iRetries)&&(nError!=ERR_OK));
		
		ThrowException(nError);

		return(nError);
		
	}//end ReadOutRegisters 
	
	
	
	public short PresetMultipleRegisters(short nAddr,  int nDataStart , short nQtd , int aiRegValues[]) {
		
		short anRegValues[];
		short nError;
		
		anRegValues=new short[aiRegValues.length];
		IntToShortArray(aiRegValues,anRegValues);
		return PresetMultipleRegisters(nAddr,nDataStart ,nQtd ,anRegValues);
		
	}

	public short PresetMultipleRegisters(short nAddr,  int nDataStart , short nQtd , float afRegValues[],int nRealType) {
		
		short anRegValues[];
		short nError;
		
		anRegValues=new short[nQtd*2];
		FloatToShortArray(afRegValues,anRegValues,nRealType);
		return PresetMultipleRegisters(nAddr,nDataStart ,(short)(nQtd*2) ,anRegValues);
		
	}