Java Jamod TCP单元标识符

在net.wimpi.modbus.facade中，ModbusSerialMaster.class包含：

public void setUnitIdentifier(int unitid) {
}

public int getUnitIdentifier() {
}

---

遗憾的是，ModbusTCPMaster.class中缺少此代码，因此它总是默认读取单元标识符或（1）。任何人都可以建议一种解决方法，或者提供将代码从串行复制到TCP。

好吧，如果有人真的使用ModBusCmpaster，并且像我一样，想通过ID与任意数量的从机进行对话，我已经更改了ModBusCmpaster.java以反映这种功能，如ModbusSerial Master.class中所示

package net.wimpi.modbus.facade;

import net.wimpi.modbus.ModbusCoupler;
import net.wimpi.modbus.ModbusException;
import net.wimpi.modbus.io.ModbusTCPTransaction;
import net.wimpi.modbus.msg.*;
import net.wimpi.modbus.net.TCPMasterConnection;
import net.wimpi.modbus.procimg.InputRegister;
import net.wimpi.modbus.procimg.Register;
import net.wimpi.modbus.util.BitVector;

import java.net.InetAddress;
import java.net.UnknownHostException;

/**
 * Modbus/TCP Master facade.
 *
 * @author Dieter Wimberger
 * @version @version@ (@date@)
 */
public class ModbusTCPMaster {

  private TCPMasterConnection m_Connection;
  private InetAddress m_SlaveAddress;
  private ModbusTCPTransaction m_Transaction;
  private ReadCoilsRequest m_ReadCoilsRequest;
  private ReadInputDiscretesRequest m_ReadInputDiscretesRequest;
  private WriteCoilRequest m_WriteCoilRequest;
  private WriteMultipleCoilsRequest m_WriteMultipleCoilsRequest;
  private ReadInputRegistersRequest m_ReadInputRegistersRequest;
  private ReadMultipleRegistersRequest m_ReadMultipleRegistersRequest;
  private WriteSingleRegisterRequest m_WriteSingleRegisterRequest;
  private WriteMultipleRegistersRequest m_WriteMultipleRegistersRequest;
  private boolean m_Reconnecting = false;

  /**
   * Constructs a new master facade instance for communication
   * with a given slave.
   *
   * @param addr an internet address as resolvable IP name or IP number,
   *             specifying the slave to communicate with.
   */
  public ModbusTCPMaster(String addr) {
    try {
      m_SlaveAddress = InetAddress.getByName(addr);
      m_Connection = new TCPMasterConnection(m_SlaveAddress);
      m_ReadCoilsRequest = new ReadCoilsRequest();
      m_ReadInputDiscretesRequest = new ReadInputDiscretesRequest();
      m_WriteCoilRequest = new WriteCoilRequest();
      m_WriteMultipleCoilsRequest = new WriteMultipleCoilsRequest();
      m_ReadInputRegistersRequest = new ReadInputRegistersRequest();
      m_ReadMultipleRegistersRequest = new ReadMultipleRegistersRequest();
      m_WriteSingleRegisterRequest = new WriteSingleRegisterRequest();
      m_WriteMultipleRegistersRequest = new WriteMultipleRegistersRequest();

    } catch (UnknownHostException e) {
      throw new RuntimeException(e.getMessage());
    }
  }//constructor

  /**
   * Constructs a new master facade instance for communication
   * with a given slave.
   *
   * @param addr an internet address as resolvable IP name or IP number,
   *             specifying the slave to communicate with.
   * @param port the port the slave is listening to.
   */
  public ModbusTCPMaster(String addr, int port) {
    this(addr);
    m_Connection.setPort(port);
  }//constructor

  /**
   * Connects this <tt>ModbusTCPMaster</tt> with the slave.
   *
   * @throws Exception if the connection cannot be established.
   */
  public void connect()
      throws Exception {
    if (m_Connection != null && !m_Connection.isConnected()) {
      m_Connection.connect();
      m_Transaction = new ModbusTCPTransaction(m_Connection);
      m_Transaction.setReconnecting(m_Reconnecting);
    }
  }//connect

  /**
   * Disconnects this <tt>ModbusTCPMaster</tt> from the slave.
   */
  public void disconnect() {
    if (m_Connection != null && m_Connection.isConnected()) {
      m_Connection.close();
      m_Transaction = null;
    }
  }//disconnect

  /**
   * Sets the flag that specifies whether to maintain a
   * constant connection or reconnect for every transaction.
   *
   * @param b true if a new connection should be established for each
   *          transaction, false otherwise.
   */
  public void setReconnecting(boolean b) {
    m_Reconnecting = b;
    if (m_Transaction != null) {
      m_Transaction.setReconnecting(b);
    }
  }//setReconnecting

  /**
   * Tests if a constant connection is maintained or if a new
   * connection is established for every transaction.
   *
   * @return true if a new connection should be established for each
   *         transaction, false otherwise.
   */
  public boolean isReconnecting() {
    return m_Reconnecting;
  }//isReconnecting

  /**
   * Reads a given number of coil states from the slave.
   * <p/>
   * Note that the number of bits in the bit vector will be
   * forced to the number originally requested.
   *
     * @param unitid
   * @param ref   the offset of the coil to start reading from.
   * @param count the number of coil states to be read.
   * @return a <tt>BitVector</tt> instance holding the
   *         received coil states.
   * @throws ModbusException if an I/O error, a slave exception or
   *                         a transaction error occurs.
   */
  public synchronized BitVector readCoils(int unitid, int ref, int count)
      throws ModbusException {
    m_ReadCoilsRequest.setUnitID(unitid);
    m_ReadCoilsRequest.setReference(ref);
    m_ReadCoilsRequest.setBitCount(count);
    m_Transaction.setRequest(m_ReadCoilsRequest);
    m_Transaction.execute();
    BitVector bv = ((ReadCoilsResponse) m_Transaction.getResponse()).getCoils();
    bv.forceSize(count);
    return bv;
  }//readCoils

  /**
   * Writes a coil state to the slave.
   *
   * @param unitid the slave unit id.
   * @param ref    the offset of the coil to be written.
   * @param state  the coil state to be written.
   * @return the state of the coil as returned from the slave.
   * @throws ModbusException if an I/O error, a slave exception or
   *                         a transaction error occurs.
   */
  public synchronized boolean writeCoil(int unitid, int ref, boolean state)
      throws ModbusException {
    m_WriteCoilRequest.setUnitID(unitid);
    m_WriteCoilRequest.setReference(ref);
    m_WriteCoilRequest.setCoil(state);
    m_Transaction.setRequest(m_WriteCoilRequest);
    m_Transaction.execute();
    return ((WriteCoilResponse) m_Transaction.getResponse()).getCoil();
  }//writeCoil

  /**
   * Writes a given number of coil states to the slave.
   * <p/>
   * Note that the number of coils to be written is given
   * implicitly, through {@link BitVector#size()}.
   *
   * @param ref   the offset of the coil to start writing to.
   * @param coils a <tt>BitVector</tt> which holds the coil states to be written.
   * @throws ModbusException if an I/O error, a slave exception or
   *                         a transaction error occurs.
   */
  public synchronized void writeMultipleCoils(int unitid, int ref, BitVector coils)
      throws ModbusException {
    m_WriteMultipleCoilsRequest.setUnitID(unitid);
    m_WriteMultipleCoilsRequest.setReference(ref);
    m_WriteMultipleCoilsRequest.setCoils(coils);
    m_Transaction.setRequest(m_WriteMultipleCoilsRequest);
    m_Transaction.execute();
  }//writeMultipleCoils

  /**
   * Reads a given number of input discrete states from the slave.
   * <p/>
   * Note that the number of bits in the bit vector will be
   * forced to the number originally requested.
   *
   * @param ref   the offset of the input discrete to start reading from.
   * @param count the number of input discrete states to be read.
   * @return a <tt>BitVector</tt> instance holding the received input discrete
   *         states.
   * @throws ModbusException if an I/O error, a slave exception or
   *                         a transaction error occurs.
   */
  public synchronized BitVector readInputDiscretes(int unitid, int ref, int count)
      throws ModbusException {
    m_ReadInputDiscretesRequest.setUnitID(unitid);
    m_ReadInputDiscretesRequest.setReference(ref);
    m_ReadInputDiscretesRequest.setBitCount(count);
    m_Transaction.setRequest(m_ReadInputDiscretesRequest);
    m_Transaction.execute();
    BitVector bv = ((ReadInputDiscretesResponse) m_Transaction.getResponse()).getDiscretes();
    bv.forceSize(count);
    return bv;
  }//readInputDiscretes


  /**
   * Reads a given number of input registers from the slave.
   * <p/>
   * Note that the number of input registers returned (i.e. array length)
   * will be according to the number received in the slave response.
   *
   * @param ref   the offset of the input register to start reading from.
   * @param count the number of input registers to be read.
   * @return a <tt>InputRegister[]</tt> with the received input registers.
   * @throws ModbusException if an I/O error, a slave exception or
   *                         a transaction error occurs.
   */
  public synchronized InputRegister[] readInputRegisters(int unitid, int ref, int count)
      throws ModbusException {
    m_ReadInputRegistersRequest.setUnitID(unitid);
    m_ReadInputRegistersRequest.setReference(ref);
    m_ReadInputRegistersRequest.setWordCount(count);
    m_Transaction.setRequest(m_ReadInputRegistersRequest);
    m_Transaction.execute();
    return ((ReadInputRegistersResponse) m_Transaction.getResponse()).getRegisters();
  }//readInputRegisters

  /**
   * Reads a given number of registers from the slave.
   * <p/>
   * Note that the number of registers returned (i.e. array length)
   * will be according to the number received in the slave response.
   *
   * @param ref   the offset of the register to start reading from.
   * @param count the number of registers to be read.
   * @return a <tt>Register[]</tt> holding the received registers.
   * @throws ModbusException if an I/O error, a slave exception or
   *                         a transaction error occurs.
   */
  public synchronized Register[] readMultipleRegisters(int unitid, int ref, int count)
      throws ModbusException {
    m_ReadMultipleRegistersRequest.setUnitID(unitid);
    m_ReadMultipleRegistersRequest.setReference(ref);
    m_ReadMultipleRegistersRequest.setWordCount(count);
    m_Transaction.setRequest(m_ReadMultipleRegistersRequest);
    m_Transaction.execute();
    return ((ReadMultipleRegistersResponse) m_Transaction.getResponse()).getRegisters();
  }//readMultipleRegisters

  /**
   * Writes a single register to the slave.
   *
   * @param ref      the offset of the register to be written.
   * @param register a <tt>Register</tt> holding the value of the register
   *                 to be written.
   * @throws ModbusException if an I/O error, a slave exception or
   *                         a transaction error occurs.
   */
  public synchronized void writeSingleRegister(int unitid, int ref, Register register)
      throws ModbusException {
    m_WriteSingleRegisterRequest.setUnitID(unitid);
    m_WriteSingleRegisterRequest.setReference(ref);
    m_WriteSingleRegisterRequest.setRegister(register);
    m_Transaction.setRequest(m_WriteSingleRegisterRequest);
    m_Transaction.execute();
  }//writeSingleRegister

  /**
   * Writes a number of registers to the slave.
   *
   * @param ref       the offset of the register to start writing to.
   * @param registers a <tt>Register[]</tt> holding the values of
   *                  the registers to be written.
   * @throws ModbusException if an I/O error, a slave exception or
   *                         a transaction error occurs.
   */
  public synchronized void writeMultipleRegisters(int unitid, int ref, Register[] registers)
      throws ModbusException {
    m_WriteMultipleRegistersRequest.setUnitID(unitid);
    m_WriteMultipleRegistersRequest.setReference(ref);
    m_WriteMultipleRegistersRequest.setRegisters(registers);
    m_Transaction.setRequest(m_WriteMultipleRegistersRequest);
    m_Transaction.execute();
  }//writeMultipleRegisters

}//class ModbusTCPMaster

package net.wimpi.modbus.facade；
导入net.wimpi.modbus.modbus耦合器；
导入net.wimpi.modbus.modbus异常；
导入net.wimpi.modbus.io.ModbusTCPTransaction；
导入net.wimpi.modbus.msg.*；
导入net.wimpi.modbus.net.TCPMasterConnection；
导入net.wimpi.modbus.procimg.InputRegister；
导入net.wimpi.modbus.procimg.Register；
导入net.wimpi.modbus.util.BitVector；
导入java.net.InetAddress；
导入java.net.UnknownHostException；
/**
*Modbus/TCP主外观。
*
*@作者迪特尔·温伯格
*@version@version@（@date@）
*/
公共类ModbusTCPMaster{
专用TCPMasterConnection mu连接；
私有地址m_SlaveAddress；
私人ModBustCPM_交易；
私有ReadCoilsRequest m_ReadCoilsRequest；
私有ReadInputDiscretesRequest m_ReadInputDiscretesRequest；
私有WriteCoilRequest m_WriteCoilRequest；
私有WriteMultipleCoilsRequest m_WriteMultipleCoilsRequest；
私人ReadInputRegistersRequest m_ReadInputRegistersRequest；
私有ReadMultipleRegistersRequest m_ReadMultipleRegistersRequest；
private WriteSingleRegisterRequest m_WriteSingleRegisterRequest；
私有WriteMultipleRegisterRequest m_WriteMultipleRegisterRequest；
私有布尔m_重新连接=false；
/**
*为通信构造一个新的主facade实例
*和一个给定的奴隶。
*
*@param addr作为可解析IP名称或IP号码的internet地址，
*指定要与之通信的从属设备。
*/
公共ModBustCmaster（字符串地址）{
试一试{
m_SlaveAddress=InetAddress.getByName（addr）；
m_连接=新的TCPMasterConnection（m_SlaveAddress）；
m_ReadCoilsRequest=新的ReadCoilsRequest（）；
m_ReadInputDiscretesRequest=新的ReadInputDiscretesRequest（）；
m_WriteCoilRequest=新的WriteCoilRequest（）；
m_WriteMultipleCoilsRequest=新的WriteMultipleCoilsRequest（）；
m_ReadInputRegistersRequest=新的ReadInputRegistersRequest（）；
m_ReadMultipleRegistersRequest=新的ReadMultipleRegistersRequest（）；
m_WriteSingleRegisterRequest=新WriteSingleRegisterRequest（）；
m_WriteMultipleRegisterRequest=新的WriteMultipleRegisterRequest（）；
}捕获（未知后异常e）{
抛出新的RuntimeException（例如getMessage（））；
}
}//建造师
/**
*为通信构造一个新的主facade实例
*和一个给定的奴隶。
*
*@param addr作为可解析IP名称或IP号码的internet地址，
*指定要与之通信的从属设备。
*@param port从机正在侦听的端口。
*/
公共ModBustCmaster（字符串地址，int端口）{
这（地址）；
m_连接。设置端口（端口）；
}//建造师
/**
*将此ModbusTCPMaster与从机连接。
*
*@在无法建立连接时引发异常。
*/
公共void connect（）
抛出异常{
if（m_Connection！=null&&！m_Connection.isConnected（））{
m_Connection.connect（）；
m_事务=新的ModbusTCPTransaction（m_连接）；
m_事务。设置重新连接（m_重新连接）；
}
}//连接
/**
*断开此ModbusTCPMaster与从机的连接。
*/
公共空间断开连接（）{
if（m_Connection！=null&&m_Connection.isConnected（））{
m_连接。关闭（）；
m_事务=空；
}
}//断开
/**
*设置用于指定是否维护
*每次事务的持续连接或重新连接。
*
*@param b如果应为每个节点建立新连接，则为true
*交易，否则为假。
*/
公共无效集合重新连接（布尔b）{
m_重新连接=b；
如果（m_事务！=null）{
m_事务集重新连接（b）；
}
}//设置重新连接
/**
*测试是否保持恒定连接或是否有新连接
*为每个事务建立连接。
*
*@如果应为每个端口建立新连接，则返回true
*交易，否则为假。
*/
公共布尔值isReconnection（）{
返回m_重新连接；
}//isReconnection
/**
*从从机读取给定数量的线圈状态。
*

*请注意，位向量中的位数将为
*强制输入最初请求的号码。
*
*@param unitid
*@param ref开始读取的线圈偏移量。
*@param计算要读取的线圈状态数。
*@返回一个包含
*接收线圈状态。
*@在I/O错误、从属异常或
*发生事务错误。
*/
公共同步位向量读线圈（int unitid、int ref、int count）
抛出ModbusException{
m_ReadCoilsRequest.setUnitID（unitid）；
m_ReadCoilsRequest.setReference（ref）；
m_ReadCoilsRequest.setBitCount（计数）；
m_Transaction.setRequest（m_ReadCoilsRequest）；
m_Transaction.execute（）；
位向量bv=（（ReadCoilsResponse）m_Transaction.getResponse（））.getCoils（）；
bv.力大小（计数）；
返回bv；
}//读线圈
/**
*将线圈状态写入从机。
*
*@param unitid是从设备id。
*@param ref待写入线圈的偏移量。
*@param state要写入的线圈状态。
*@返回从机返回的线圈状态。
*@在I/O错误、从属异常或
*发生事务错误。