I want to improve my code. In this code I don't like my contructor, but without it I keep getting an error while trying to connect NullPointerException.Any suggestions are welcome.

package soft;
import java.net.InetAddress;
import java.net.UnknownHostException;
import javax.swing.JOptionPane;
import net.wimpi.modbus.ModbusException;
import net.wimpi.modbus.ModbusIOException;
import net.wimpi.modbus.ModbusSlaveException;
import net.wimpi.modbus.io.ModbusSerialTransaction;
import net.wimpi.modbus.io.ModbusTCPTransaction;
import net.wimpi.modbus.msg.ReadCoilsRequest;
import net.wimpi.modbus.msg.ReadCoilsResponse;
import net.wimpi.modbus.msg.ReadInputDiscretesRequest;
import net.wimpi.modbus.msg.ReadInputDiscretesResponse;
import net.wimpi.modbus.msg.ReadInputRegistersRequest;
import net.wimpi.modbus.msg.ReadInputRegistersResponse;
import net.wimpi.modbus.msg.ReadMultipleRegistersRequest;
import net.wimpi.modbus.msg.ReadMultipleRegistersResponse;
import net.wimpi.modbus.msg.WriteMultipleRegistersRequest;
import net.wimpi.modbus.msg.WriteMultipleRegistersResponse;
import net.wimpi.modbus.msg.WriteSingleRegisterRequest;
import net.wimpi.modbus.msg.WriteSingleRegisterResponse;
import net.wimpi.modbus.net.SerialConnection;
import net.wimpi.modbus.net.TCPMasterConnection;
import net.wimpi.modbus.procimg.Register;
import net.wimpi.modbus.procimg.SimpleRegister;
import net.wimpi.modbus.util.SerialParameters;
/**
 * This class realizes modbus protocol
 * communication over TCP and Serial Port and most of modbus functions.
 *
 * @author Tomas Ausvicas
 */
public class BackEnd {

/** The tcp con. */
TCPMasterConnection tcpCon;
/** The serial con. */
SerialConnection serialCon;
/** The transaction tcp. */
ModbusTCPTransaction transactionTCP;
/** The transaction serial. */
ModbusSerialTransaction transactionSerial;
/** The params. */
SerialParameters params = new SerialParameters();
/** The rcreq. */
ReadCoilsRequest rcreq = new ReadCoilsRequest();
/** The rcres. */
ReadCoilsResponse rcres = new ReadCoilsResponse();
/** The rireq. */
ReadInputRegistersRequest rireq = new ReadInputRegistersRequest();
/** The rires. */
ReadInputRegistersResponse rires = new ReadInputRegistersResponse();
/** The ridreq. */
ReadInputDiscretesRequest ridreq = new ReadInputDiscretesRequest();
/** The ridres. */
ReadInputDiscretesResponse ridres = new ReadInputDiscretesResponse();
/** The write_sreq. */
WriteSingleRegisterRequest write_sreq = new WriteSingleRegisterRequest();
/** The write_sres. */
WriteSingleRegisterResponse write_sres = new WriteSingleRegisterResponse();
/** The read_mreq. */
ReadMultipleRegistersRequest read_mreq = new ReadMultipleRegistersRequest();
/** The read_mres. */
ReadMultipleRegistersResponse read_mres = new `ReadMultipleRegistersResponse();`
/** The write_mreq. */
WriteMultipleRegistersRequest write_mreq = new WriteMultipleRegistersRequest();
/** The write_mres. */
WriteMultipleRegistersResponse write_mres = new WriteMultipleRegistersResponse();
/** The register. */
SimpleRegister regL, regH, register;
/** The registers. */
Register[] registers;
/** The int16 result. */
private int[] int16Result;
/** The int32 result. */
private int[] int32Result;
/** The float result. */
private float[] floatResult;
/** The round float result. */
private float[] roundFloatResult;
/** The string16 result. */
private String[] string16Result;
/** The string32 result. */
private String[] string32Result;
/** The string float result. */
private String[] stringFloatResult;
/** The round string float result. */
private String[] roundStringFloatResult;
/** The string coil result. */
private String[] stringCoilResult;
/** The boolean coil result. */
private boolean[] booleanCoilResult;
/** The string discrete input result. */
private String[] stringDiscreteInputResult;
/** The boolean discrete input result. */
private boolean[] booleanDiscreteInputResult;
/** The string read bit result. */
private String[] stringReadBitResult;
/** The boolean read bit result. */
private boolean[] booleanReadBitResult;
/** The int analog input registers result. */
private int[] intAnalogInputRegistersResult;
/** The string analog input registers result. */
private String[] stringAnalogInputRegistersResult;
/** The to string. */
private String[] toString;
/**
 * Default constructor with TCP and Serial Port objects created.
 */
public BackEnd() {
try {
 tcpCon = new TCPMasterConnection(InetAddress.getByName(""));
} catch (UnknownHostException e) {
 System.out.println("Unknow Host");
}
params = new SerialParameters();
serialCon = new SerialConnection(params);
}
/**
 * Connect over TCP.
 *
 * @param ipAddress the ip address
 * @param port the port
 */
public void connectTCP(String ipAddress, int port) {
 try {
  tcpCon = new TCPMasterConnection(InetAddress.getByName(ipAddress));
 } catch (UnknownHostException e1) {
 JOptionPane.showMessageDialog(null, "Įveskite IP adresą", "Invalid input", JOptionPane.WARNING_MESSAGE);
 }
 tcpCon.setPort(port);
 try {
  tcpCon.connect();
 } catch (Exception e) {
 JOptionPane.showMessageDialog(null, "Nepavyko prisijungti prie serverio. [TCP/IP]", "Connection error",
  JOptionPane.ERROR_MESSAGE);
 }
  transactionTCP = new ModbusTCPTransaction(tcpCon);
  
}
/**
 * Set parameters for serial com.
 *
 * @param portName the port name
 * @param baudRate the baud rate
 * @param dataBits the data bits
 * @param stopBits the stop bits
 * @param parity the parity
 * @param encoding the encoding
 * @param echo the echo
 */
public void connectSerial(String portName, int baudRate, int dataBits, int stopBits, String parity, String encoding,
 boolean echo) {
 SerialParameters params = new SerialParameters();
 params.setPortName(portName);
 params.setDatabits(dataBits);
 params.setParity(parity);
 params.setStopbits(stopBits);
 params.setEncoding(encoding);
 params.setEcho(echo);
 params.setBaudRate(baudRate);
 serialCon = new SerialConnection(params);
 try {
 serialCon.open();
 } catch (Exception e) {
 JOptionPane.showMessageDialog(null, "Nepavyko prisijungti prie serverio. [Serial port]", "Connection error",
 JOptionPane.ERROR_MESSAGE);
 }
 transactionSerial = new ModbusSerialTransaction(serialCon);
}

/**
 * Close TCP connection.
 */
public void closeTCP() {
 tcpCon.close();
}
/**
 * Close Serial connection.
 */
public void closeSerial() {
 serialCon.close();
}
/**
 * Check if TCP connected.
 *
 * @return boolean value
 */
public boolean isConnectedTCP() {
 return tcpCon.isConnected();
 
}
/**
 * Check if Serial connected.
 *
 * @return boolean value
 */
public boolean isOpenSerial() {
 return serialCon.isOpen();
}
/**
 * Writes single 16bit number to register (16 bit integer).
 *
 * @param unitID the unit id
 * @param startAddress the start address
 * @param dataToWrite the data to write
 */
public void WriteSingle_16Bit(int unitID, int startAddress, int dataToWrite) {
 SimpleRegister reg = new SimpleRegister(dataToWrite);
 write_sreq.setReference(startAddress);
 write_sreq.setUnitID(unitID);
 write_sreq.setRegister(reg);
 try {
 transaction(transactionTCP, transactionSerial, write_sreq);
 } catch (ModbusIOException e) {
 System.out.println("Modbus IO Exception write 16");
 } catch (ModbusSlaveException e) {
 System.out.println("Modbus Slave Exception write 16");
 } catch (ModbusException e) {
 System.out.println("Modbus Exception write 16");
 }
}
/**
 * Writes double 16bit number to register (32 bit integer).
 *
 * @param unitID the unit id
 * @param startAddress the start address
 * @param dataToWrite the data to write
 */
public void WriteSingle_32Bit(int unitID, int startAddress, int dataToWrite) {

 int count = 2;
 int HIGH = dataToWrite >> 16;
 int LOW = dataToWrite & 0xFFFF;
 regH = new SimpleRegister(HIGH);
 regL = new SimpleRegister(LOW);
 registers = new Register[count];
 for (int i = 0, a = 1; i < registers.length; i += 2, a += 2) {
 registers[i] = regL;
 registers[a] = regH;
 }
 write_mreq.setReference(startAddress);
 write_mreq.setUnitID(unitID);
  write_mreq.setRegisters(registers);
 try {
 transaction(transactionTCP, transactionSerial, write_mreq);
 } catch (ModbusIOException e) {
 System.out.println("Modbus IO Exception write 32");
 } catch (ModbusSlaveException e) {
 System.out.println("Modbus Slave Exception write 32");
 } catch (ModbusException e) {
 System.out.println("Modbus Exception write 32");
 }
}
/**
 * Writes double 16bit number to register (32bit float).
 *
 * @param unitID the unit id
 * @param startAddress the start address
 * @param dataToWriteF the data to write f
 */
public void WriteSingle_Float(int unitID, int startAddress, float dataToWriteF) {
 int count = 2;
 int number = Float.floatToIntBits(dataToWriteF);
  int HIGH = number >> 16;
 int LOW = number & 0xFFFF;
 regH = new SimpleRegister(HIGH);
 regL = new SimpleRegister(LOW);
 registers = new Register[count];
 for (int i = 1, a = 0; i < registers.length; i += 2, a += 2) {
 registers[i] = regL;
 registers[a] = regH;
 }
 write_mreq.setReference(startAddress);
 write_mreq.setUnitID(unitID);
 write_mreq.setRegisters(registers);
 try {
 transaction(transactionTCP, transactionSerial, write_mreq);
  } catch (ModbusIOException e) {
  System.out.println("Modbus IO Exception write float");
 } catch (ModbusSlaveException e) {
 System.out.println("Modbus Slave Exception write float");
 } catch (ModbusException e) {
 System.out.println("Modbus Exception write float");
 }
}
/**
 * Writes multiple 16bit numbers to chosen registers (16bit integer).
 *
 * @param unitID the unit id
 * @param startAddress the start address
 * @param dataToWrite the data to write
 * @param count the count
 */
public void WriteMultiple_16Bit(int unitID, int startAddress, int dataToWrite, int count) {
 register = new SimpleRegister(dataToWrite);
 registers = new Register[count];
 for (int i = 0; i < registers.length; i++) {
 registers[i] = register;
 }
 write_mreq.setReference(startAddress);
 write_mreq.setUnitID(unitID);
 write_mreq.setRegisters(registers);
 try {
 transaction(transactionTCP, transactionSerial, write_mreq);
 } catch (ModbusIOException e) {
 System.out.println("Modbus IO Exception mwrite 16");
 } catch (ModbusSlaveException e) {
 System.out.println("Modbus Slave Exception mwrite 16");
 } catch (ModbusException e) {
 System.out.println("Modbus Exception mwrite 16");
 }
}

/**
 * Writes multiple double 16bit numbers to chosen registers (32bit integer).
 *
 * @param unitID the unit id
 * @param startAddress the start address
 * @param dataToWrite the data to write
 * @param count the count
 */
public void WriteMultiple_32Bit(int unitID, int startAddress, int dataToWrite, int count) {
 int HIGH = dataToWrite >> 16;
 int LOW = dataToWrite & 0xFFFF;
 regH = new SimpleRegister(HIGH);
 regL = new SimpleRegister(LOW);
 registers = new Register[count * 2];
 for (int i = 0, a = 1; i < registers.length; i += 2, a += 2) {
 registers[i] = regL;
 registers[a] = regH;
 }
 write_mreq.setReference(startAddress);
 write_mreq.setUnitID(unitID);
 write_mreq.setRegisters(registers);
 try {
 transaction(transactionTCP, transactionSerial, write_mreq);
 } catch (ModbusIOException e) {
 System.out.println("Modbus IO Exception mwrite 32");
 } catch (ModbusSlaveException e) {
 System.out.println("Modbus Slave Exception mwrite 32");
 } catch (ModbusException e) {
 System.out.println("Modbus Exception mwrite 32");
 }
}

/**
 * Writes multiple double 16bit numbers to chosen registers (32bit float).
 *
 * @param unitID the unit id
 * @param startAddress the start address
 * @param dataToWriteF the data to write f
 * @param count the count
 */
public void WriteMultiple_Float(int unitID, int startAddress, float dataToWriteF, int count) {
 int number = Float.floatToIntBits(dataToWriteF);
  int HIGH = number >> 16;
 int LOW = number & 0xFFFF;
 regH = new SimpleRegister(HIGH);
 regL = new SimpleRegister(LOW);
 registers = new Register[count * 2];
 for (int i = 1, a = 0; i < registers.length; i += 2, a += 2) {
 registers[i] = regL;
 registers[a] = regH;
  }
 write_mreq.setReference(startAddress);
 write_mreq.setUnitID(unitID);
 write_mreq.setRegisters(registers);
 try {
 transaction(transactionTCP, transactionSerial, write_mreq);
  } catch (ModbusIOException e) {
 System.out.println("Modbus IO Exception mwrite float"); } catch (ModbusSlaveException e) {
 System.out.println("Modbus Slave Exception mwrite float");
 } catch (ModbusException e) {
  System.out.println("Modbus Exception mwrite float");
 }
}
/**
 * Reads multiple 16bit numbers from chosen registers (16bit integer).
 *
 * @param unitID the unit id
 * @param startAddress the start address
 * @param count the count
 * @return multiple registers
 */
public BackEnd ReadMultiple_16Bit(int unitID, int startAddress, int count) {
 this.int16Result = new int[count];
 this.string16Result = new String[count];
 read_mreq.setUnitID(unitID);
 read_mreq.setReference(startAddress);
 read_mreq.setWordCount(count);
 try {
 transaction(transactionTCP, transactionSerial, read_mreq);
 } catch (ModbusIOException e) {
 System.out.println("Modbus IO Exception mread 16");
 } catch (ModbusSlaveException e) {
 System.out.println("Modbus Slave Exception mread 16");
 } catch (ModbusException e) {
 System.out.println("Modbus Exception mread 16");
 }
 for (int n = 0; n < read_mres.getWordCount(); n++) {
 int16Result[n] = read_mres.getRegisterValue(n);
 string16Result[n] = String.valueOf(int16Result[n]);
 }
 return this;
}
/**
 * Reads multiple double 16bit numbers from chosen registers (32bit integer).
 *
 * @param unitID the unit id
 * @param startAddress the start address
 * @param count the count
 * @return multiple registers
 */
public BackEnd ReadMultiple_32Bit(int unitID, int startAddress, int count) {
 this.int32Result = new int[count];
 this.string32Result = new String[count];
 int[] z = new int[count * 2];
 int[] y = new int[count * 2];
 int[] h = new int[count];
 int[] l = new int[count];
 read_mreq.setUnitID(unitID);
 read_mreq.setReference(startAddress);
 read_mreq.setWordCount(count * 2);
 try {
 transaction(transactionTCP, transactionSerial, read_mreq);
  } catch (ModbusIOException e) {
 System.out.println("Modbus IO Exception mread 32");
  } catch (ModbusSlaveException e) {
 System.out.println("Modbus Slave Exception mread 32");
 } catch (ModbusException e) {
 System.out.println("Modbus Exception mread 32");
 }
 for (int n = 0, i = 1; n < read_mres.getWordCount(); n += 2, i += 2) {
 z[n] = read_mres.getRegisterValue(n);
  y[i] = (read_mres.getRegisterValue(i) << 16);
 }
 for (int a = 0, b = 0; a < l.length; a++, b += 2) {
 l[a] = z[b];
 }
 for (int a = 0, b = 1; a < h.length; a++, b += 2) {
  h[a] = y[b];
 }
 for (int n = 0; n < int32Result.length; n++) {
 int32Result[n] = h[n] | l[n];
 string32Result[n] = String.valueOf(int32Result[n]);
 }
 return this;
}
/**
 * Reads multiple double 16bit numbers from chosen registers (32 bit float).
 *
 * @param unitID the unit id
 * @param startAddress the start address
 * @param count the count
 * @return multiple registers
 */
public BackEnd ReadMultiple_Float(int unitID, int startAddress, int count) {
 this.floatResult = new float[count];
 this.stringFloatResult = new String[count];
 this.roundFloatResult = new float[count];
 this.roundStringFloatResult = new String[count];
 int[] x = new int[count * 2];
 int[] y = new int[count * 2];
 int[] h = new int[count];
 int[] l = new int[count];
 read_mreq.setUnitID(unitID);
 read_mreq.setReference(startAddress);
 read_mreq.setWordCount(count * 2);
 try {
 transaction(transactionTCP, transactionSerial, read_mreq);
 } catch (ModbusIOException e) {
 System.out.println("Modbus IO Exception mread float");
 } catch (ModbusSlaveException e) {
  System.out.println("Modbus Slave Exception mread float");
 } catch (ModbusException e) {
 System.out.println("Modbus Exception mread float");
  }
 for (int n = 1, i = 0; n < read_mres.getWordCount(); n += 2, i += 2) {
 x[n] = read_mres.getRegisterValue(n);
 y[i] = (read_mres.getRegisterValue(i) << 16);
 }
 for (int a = 0, b = 1; a < l.length; a++, b += 2) {
 l[a] = x[b];
 }
 for (int a = 0, b = 0; a < h.length; a++, b += 2) {
 h[a] = y[b];
 }
 for (int n = 0; n < floatResult.length; n++) {
  floatResult[n] = Float.intBitsToFloat(h[n] | l[n]);
 stringFloatResult[n] = String.valueOf(floatResult[n]);
 roundFloatResult[n] = (float) Math.round(floatResult[n] * 100) / 100;
 roundStringFloatResult[n] = Float.toString(roundFloatResult[n]);
 }
 return this;
}
/**
 * Reads multiple coils from chosen registers.
 *
 * @param unitID the unit id
 * @param startAddress the start address
 * @param count the count
 * @return coil as boolean or String
 */
public BackEnd ReadCoilStatus(int unitID, int startAddress, int count) {
 this.booleanCoilResult = new boolean[count];
 this.stringCoilResult = new String[count];
 rcreq.setReference(startAddress);
 rcreq.setBitCount(count);
 rcreq.setUnitID(unitID);
 try {
  transaction(transactionTCP, transactionSerial, rcreq);
 } catch (ModbusIOException e) {
 e.printStackTrace();
  } catch (ModbusSlaveException e) {
  e.printStackTrace();
 } catch (ModbusException e) {
  e.printStackTrace();
 }
 for (int i = 0; i < count; i++) {
  booleanCoilResult[i] = rcres.getCoilStatus(i);
  stringCoilResult[i] = String.valueOf(booleanCoilResult[i]);
 }
 return this;
}
/**
 * Reads multiple discrete inputs from chosen registers.
 *
 * @param unitID the unit id
 * @param startAddress the start address
 * @param count the count
 * @return discrete input as boolean or String
 */
public BackEnd ReadDiscreteInputStatus(int unitID, int startAddress, int count) {
 this.booleanDiscreteInputResult = new boolean[count];
 this.stringDiscreteInputResult = new String[count];
 ridreq.setReference(startAddress);
 ridreq.setBitCount(count);
 ridreq.setUnitID(unitID);
 try {
  transaction(transactionTCP, transactionSerial, ridreq);
 } catch (ModbusIOException e) {
 e.printStackTrace();
 } catch (ModbusSlaveException e) {
  e.printStackTrace();
 } catch (ModbusException e) {
 e.printStackTrace();
 }
 for (int i = 0; i < count; i++) {
 booleanDiscreteInputResult[i] = ridres.getDiscreteStatus(i);
 stringDiscreteInputResult[i] = String.valueOf(booleanDiscreteInputResult[i]);
 }
 return this;
}
/**
 * Reads multiple analog inputs from chosen registers.
 *
 * @param unitID the unit id
 * @param startAddress the start address
 * @param count the count
 * @return analog input register value (int or String)
 */
public BackEnd ReadAnalogInputRegisters(int unitID, int startAddress, int count) {
 this.intAnalogInputRegistersResult = new int[count];
 this.stringAnalogInputRegistersResult = new String[count];
 rireq.setReference(startAddress);
 rireq.setWordCount(count);
 rireq.setUnitID(unitID);
 try {
  transaction(transactionTCP, transactionSerial, rireq);
 } catch (ModbusIOException e) {
 e.printStackTrace();
 } catch (ModbusSlaveException e) {
 e.printStackTrace();
 } catch (ModbusException e) {
  e.printStackTrace();
 }
 for (int i = 0; i < count; i++) {
 intAnalogInputRegistersResult[i] = rires.getRegisterValue(i);
 stringAnalogInputRegistersResult[i] = String.valueOf(intAnalogInputRegistersResult[i]);
 }
 return this;
}
/**
 * Read bit from a register.
 *
 * @param unitID the unit id
 * @param startAddress the start address
 * @param position D15..D0
 * @param count the count
 * @return bit as boolean or String
 */
public BackEnd ReadBit(int unitID, int startAddress, int position, int count) {
 this.stringReadBitResult = new String[count];
 this.booleanReadBitResult = new boolean[count];
 this.toString = new String[count];
 // String[] toString = new String[count];
 read_mreq.setUnitID(unitID);
 read_mreq.setReference(startAddress);
 read_mreq.setWordCount(count);
 try {
  transaction(transactionTCP, transactionSerial, read_mreq);
 } catch (ModbusIOException e) {
 System.out.println("Modbus IO Exception read bit");
  } catch (ModbusSlaveException e) {
  System.out.println("Modbus Slave Exception read bit");
 } catch (ModbusException e) {
 System.out.println("Modbus Exception read bit");
 }
 for (int n = 0; n < read_mres.getWordCount(); n++) {
 try {
 toString[n] = Integer.toBinaryString(0x10000 | read_mres.getRegisterValue(n)).substring(1);
 if (toString[n].charAt(15 - position) == '0') {
 booleanReadBitResult[n] = false;
 stringReadBitResult[n] = String.valueOf(false);
 } else if (toString[n].charAt(15 - position) == '1') {
 booleanReadBitResult[n] = true;
 stringReadBitResult[n] = String.valueOf(true);
 }
 } catch (IndexOutOfBoundsException e) {
 }
 }
 return this;
}
/**
 * Write bit to a register.
 *
 * @param unitID the unit id
 * @param startAddress the start address
 * @param position D15..D0
 * @param bitas  true=0, false=1
 * @param count the count
 */
public void WriteBit(int unitID, int startAddress, int position, boolean bitas, int count) {
 String value = "";
 if (bitas == true) {
 value = "1";
 } else if (bitas == false) {
 value = "0";
 }
 int[] x = new int[count];
 String[] toString = new String[count];
 String[] Format16Bit = new String[count];
 read_mreq.setUnitID(unitID);
 read_mreq.setReference(startAddress);
 read_mreq.setWordCount(count);
 try {
 transaction(transactionTCP, transactionSerial, read_mreq);
 } catch (ModbusIOException e) {
 System.out.println("Modbus IO Exception Readwrite bit");
 } catch (ModbusSlaveException e) {
 System.out.println("Modbus Slave Exception Readwrite bit");
 } catch (ModbusException e) {
 System.out.println("Modbus Exception Readwrite bit");
 }
 for (int n = 0; n < read_mres.getWordCount(); n++) {
 toString[n] = Integer.toBinaryString(0x10000 | read_mres.getRegisterValue(n)).substring(1);
 }
 registers = new Register[count];
 for (int n = 0; n < count; n++) {
 Format16Bit[n] = toString[n].substring(0, 15 - position) + value + toString[n].substring(15 - position + 1);
  x[n] = Integer.parseInt(Format16Bit[n], 2);
 register = new SimpleRegister(x[n]);
  registers[n] = register;
 }
 write_mreq.setReference(startAddress);
 write_mreq.setRegisters(registers);
 write_mreq.setUnitID(unitID);
 try {
 transaction(transactionTCP, transactionSerial, write_mreq);
 } catch (ModbusIOException e) {
 System.out.println("Modbus IO Exception Write bit");
 } catch (ModbusSlaveException e) {
  System.out.println("Modbus Slave Exception Write bit");
 } catch (ModbusException e) {
 System.out.println("Modbus Exception Write bit");
 }
}

/**
 * Overloading method for transaction over modbus protocol.
 *
 * @param transactionTCP the transaction tcp
 * @param transactionSerial the transaction serial
 * @param write_mreq the write_mreq
 * @throws ModbusIOException the modbus io exception
 * @throws ModbusSlaveException the modbus slave exception
 * @throws ModbusException the modbus exception
 */
public void transaction(ModbusTCPTransaction transactionTCP, ModbusSerialTransaction transactionSerial,
 WriteMultipleRegistersRequest write_mreq) throws ModbusIOException, ModbusSlaveException, ModbusException {
 try {
 transactionTCP.setRequest(write_mreq);
 transactionTCP.execute();
 transactionTCP.getResponse();
 } catch (Exception e) {
 System.out.println("[TCP] write_mreq error");
 }
 try {
 transactionSerial.setRequest(write_mreq);
 transactionSerial.execute();
 transactionSerial.getResponse();
 } catch (Exception e) {
 System.out.println("[Serial] write_mreq error");
 }
}
/**
 * Overloading method.
 *
 * @param transactionTCP the transaction tcp
 * @param transactionSerial the transaction serial
 * @param write_sreq the write_sreq
 * @throws ModbusIOException the modbus io exception
 * @throws ModbusSlaveException the modbus slave exception
 * @throws ModbusException the modbus exception
 */
public void transaction(ModbusTCPTransaction transactionTCP, ModbusSerialTransaction transactionSerial,
 WriteSingleRegisterRequest write_sreq) throws ModbusIOException, ModbusSlaveException, ModbusException {
 try {
 transactionTCP.setRequest(write_sreq);
 transactionTCP.execute();
 transactionTCP.getResponse();
 } catch (Exception e) {
 System.out.println("[TCP] write_sreq error");
 }
 try {
 transactionSerial.setRequest(write_sreq);
 transactionSerial.execute();
 transactionSerial.getResponse();
 } catch (Exception e) {
 System.out.println("[Serial] write_sreq error");
 }
}
/**
 * Overloading method.
 *
 * @param transactionTCP the transaction tcp
 * @param transactionSerial the transaction serial
 * @param read_mreq the read_mreq
 * @throws ModbusIOException the modbus io exception
 * @throws ModbusSlaveException the modbus slave exception
 * @throws ModbusException the modbus exception
 */
public void transaction(ModbusTCPTransaction transactionTCP, ModbusSerialTransaction transactionSerial,
 ReadMultipleRegistersRequest read_mreq) throws ModbusIOException, ModbusSlaveException, ModbusException {
 try {
 transactionTCP.setRequest(read_mreq);
 transactionTCP.execute();
 read_mres = (ReadMultipleRegistersResponse) transactionTCP.getResponse();
 } catch (Exception e) {
 System.out.println("[TCP] read_mreq error");
 }
 try {
 transactionSerial.setRequest(read_mreq);
 transactionSerial.execute();
 read_mres = (ReadMultipleRegistersResponse) transactionSerial.getResponse();
 } catch (Exception e) {
 System.out.println("[Serial] read_mreq error");
 }
}
/**
 * Overloading method.
 *
 * @param transactionTCP the transaction tcp
 * @param transactionSerial the transaction serial
 * @param rcreq the rcreq
 * @throws ModbusIOException the modbus io exception
 * @throws ModbusSlaveException the modbus slave exception
 * @throws ModbusException the modbus exception
 */

public void transaction(ModbusTCPTransaction transactionTCP, ModbusSerialTransaction transactionSerial,
 ReadCoilsRequest rcreq) throws ModbusIOException, ModbusSlaveException, ModbusException {

 try {
 transactionTCP.setRequest(rcreq);
  transactionTCP.execute();
 rcres = (ReadCoilsResponse) transactionTCP.getResponse();
 } catch (Exception e) {
 System.out.println("[TCP] rcreq error");
 }
 try {
 transactionSerial.setRequest(rcreq);
 transactionSerial.execute();
 rcres = (ReadCoilsResponse) transactionSerial.getResponse();
 } catch (Exception e) {
 System.out.println("[Serial] rcreq error");
 }
}
/**
 * Overloading method.
 *
 * @param transactionTCP the transaction tcp
 * @param transactionSerial the transaction serial
 * @param rireq the rireq
 * @throws ModbusIOException the modbus io exception
 * @throws ModbusSlaveException the modbus slave exception
 * @throws ModbusException the modbus exception
 */
public void transaction(ModbusTCPTransaction transactionTCP, ModbusSerialTransaction transactionSerial,
 ReadInputRegistersRequest rireq) throws ModbusIOException, ModbusSlaveException, ModbusException {

 try {
 transactionTCP.setRequest(rireq);
 transactionTCP.execute();
 rires = (ReadInputRegistersResponse) transactionTCP.getResponse();
 } catch (Exception e) {
 System.out.println("[TCP] rireq error");
 }
 try {
 transactionSerial.setRequest(rireq);
 transactionSerial.execute();
 rires = (ReadInputRegistersResponse) transactionSerial.getResponse();
 } catch (Exception e) {
 System.out.println("[Serial] rireq error");
 }
}
/**
 * Overloading method.
 *
 * @param transactionTCP the transaction tcp
 * @param transactionSerial the transaction serial
 * @param ridreq the ridreq
 * @throws ModbusIOException the modbus io exception
 * @throws ModbusSlaveException the modbus slave exception
 * @throws ModbusException the modbus exception
 */

public void transaction(ModbusTCPTransaction transactionTCP, ModbusSerialTransaction transactionSerial,
 ReadInputDiscretesRequest ridreq) throws ModbusIOException, ModbusSlaveException, ModbusException {

 try {
 transactionTCP.setRequest(ridreq);
  transactionTCP.execute();
 ridres = (ReadInputDiscretesResponse) transactionTCP.getResponse();
 } catch (Exception e) {
 System.out.println("[TCP] ridreq error");
 }
 try {
 transactionSerial.setRequest(ridreq);
 transactionSerial.execute();
 ridres = (ReadInputDiscretesResponse) transactionSerial.getResponse();
 } catch (Exception e) {
 System.out.println("[Serial] ridreq error");
 }
}
 /**
 * Gets the 16 bit int.
 *
 * @return 16bit numbers as int array
 */
public int[] get16BitInt() {
  return int16Result;
}
/**
 * Gets the 32 bit int.
 *
 * @return 32bit numbers as int array
 */
public int[] get32BitInt() {
 return int32Result;
}
/**
 * Gets the float.
 *
 * @return 32bit float numbers as float array
 */
public float[] getFloat() {
  return floatResult;
}
/**
 * Gets the round float.
 *
 * @return 32bit float numbers as rounded float array
 */
public float[] getRoundFloat() {
 return roundFloatResult;
}
/**
 * Gets the 16 bit string.
 *
 * @return 16bit numbers as String array
 */
public String[] get16BitString() {
 return string16Result;
}
/**
 * Gets the 32 bit string.
 *
 * @return 32bit numbers as String array
 */
public String[] get32BitString() {
 return string32Result;
}
/**
 * Gets the float string.
 *
 * @return 32bit float numbers as String array
 */
public String[] getFloatString() {
 return stringFloatResult;
}
/**
 * Gets the round float string.
 *
 * @return 32bit float numbers as rounded String array
 */
public String[] getRoundFloatString() {
 return roundStringFloatResult;
}
/**
 * Gets the 16 bit at index.
 *
 * @param index the index
 * @return 16bit number from int array at index
 */
public int get16BitAtIndex(int index) {
 return int16Result[index];
}
/**
 * Gets the 32 bit at index.
 *
 * @param index the index
 * @return 32bit number from int array at index
 */
public int get32BitAtIndex(int index) {
 return int32Result[index];
}
/**
 * Gets the float at index.
 *
 * @param index the index
 * @return 32bit foat number from float array at index
 */
public float getFloatAtIndex(int index) {
 return floatResult[index];
}
/**
 * Gets the round float at index.
 *
 * @param index the index
 * @return 32bit rounded float number from rounded float array at index
 */
public float getRoundFloatAtIndex(int index) {
 return roundFloatResult[index];
}
/**
 * Gets the 16 bit string at index.
 *
 * @param index the index
 * @return 16bit rounded float number from rounded String array at index
 */
public String get16BitStringAtIndex(int index) {
 return string16Result[index];
}
/**
 * Gets the 32 bit string at index.
 *
 * @param index the index
 * @return 32bit number from String array at index
 */
public String get32BitStringAtIndex(int index) {
 return string32Result[index];
}
/**
 * Gets the float string at index.
 *
 * @param index the index
 * @return 32bit float number from String array at index
 */
public String getFloatStringAtIndex(int index) {
 return stringFloatResult[index];
}
/**
 * Gets the round float string at index.
 *
 * @param index the index
 * @return 32bit rounded float number from rounded String array at index
 */
public String getRoundFloatStringAtIndex(int index) {
 return roundStringFloatResult[index];
}
/**
 * Gets the coil boolean at index.
 *
 * @param index the index
 * @return coil status from boolean array at index
 */
public Boolean getCoilBooleanAtIndex(int index) {
 return booleanCoilResult[index];
}
/**
 * Gets the coil string at index.
 *
 * @param index the index
 * @return coil status from String array at index
 */
public String getCoilStringAtIndex(int index) {
 return stringCoilResult[index];
}
/**
 * Gets the coil boolean.
 *
 * @return coil status from boolean array
 */
public boolean[] getCoilBoolean() {
 return booleanCoilResult;
}
/**
 * Gets the coil string.
 *
 * @return coil status from String array
 */
public String[] getCoilString() {
 return stringCoilResult;
}
/**
 * Gets the read bit boolean.
 *
 * @return bit status from boolean array
 */
public boolean[] getReadBitBoolean() {
 return booleanReadBitResult;
}
/**
 * Gets the read bit boolean at index.
 *
 * @param index the index
 * @return bit status from boolean array at index
 */
public boolean getReadBitBooleanAtIndex(int index) {
 return booleanReadBitResult[index];
}
/**
 * Gets the read bit string.
 *
 * @return bit status from String array
 */
public String[] getReadBitString() {
 return stringReadBitResult;
}
/**
 * Gets the read bit string bin.
 *
 * @return String binary format (01010101..)
 */
public String[] getReadBitStringBin() {
 StringBuilder[] str = new StringBuilder[toString.length];
 for (int i = 0; i < str.length; i++) {
 str[i] = new StringBuilder(toString[i]);
 int idx = str[i].length() - 4;
 while (idx > 0) {
 str[i].insert(idx, " ");
 toString[i] = str[i].toString();
 idx = idx - 4;
 }
 }
 return toString;
}

/**
 * Gets the read bit string at index.
 *
 * @param index the index
 * @return bit status from String array at index
 */
public String getReadBitStringAtIndex(int index) {
 return stringReadBitResult[index];
}
/**
 * Gets the boolean discrete input result.
 *
 * @return dicrete input status from boolean array
 */
public boolean[] getBooleanDiscreteInputResult() {
 return booleanDiscreteInputResult;
}
/**
 * Gets the boolean discrete input result at index.
 *
 * @param index the index
 * @return dicrete input status from boolean array at index
 */
public boolean getBooleanDiscreteInputResultAtIndex(int index) {
 return booleanDiscreteInputResult[index];
}
/**
 * Gets the string discrete input result.
 *
 * @return dicrete input status from String array
 */
public String[] getStringDiscreteInputResult() {
 return stringDiscreteInputResult;
}
/**
 * Gets the string discrete input result at index.
 *
 * @param index the index
 * @return dicrete input status from String array at index
 */
public String getStringDiscreteInputResultAtIndex(int index) {
 return stringDiscreteInputResult[index];
}
/**
 * Gets the int analog input registers result.
 *
 * @return analog input status from int array
 */
public int[] getIntAnalogInputRegistersResult() {
 return intAnalogInputRegistersResult;
}
/**
 * Gets the int analog input registers result at index.
 *
 * @param index the index
 * @return analog input status from int array at index
 */
public int getIntAnalogInputRegistersResultAtIndex(int index) {
 return intAnalogInputRegistersResult[index];
}
/**
 * Gets the string analog input registers result.
 *
 * @return analog input status from String array
 */
public String[] getStringAnalogInputRegistersResult() {
 return stringAnalogInputRegistersResult;
}
/**
 * Gets the string analog input registers result at index.
 *
 * @param index the index
 * @return analog input status from String array at index
 */
public String getStringAnalogInputRegistersResultAtIndex(int index) {
 return stringAnalogInputRegistersResult[index];
}

}

I want to improve my code. In this code I don't like my constructor, but without it I keep getting an error while trying to connect NullPointerException.

package soft;
import java.net.InetAddress;
import java.net.UnknownHostException;
import javax.swing.JOptionPane;
import net.wimpi.modbus.ModbusException;
import net.wimpi.modbus.ModbusIOException;
import net.wimpi.modbus.ModbusSlaveException;
import net.wimpi.modbus.io.ModbusSerialTransaction;
import net.wimpi.modbus.io.ModbusTCPTransaction;
import net.wimpi.modbus.msg.ReadCoilsRequest;
import net.wimpi.modbus.msg.ReadCoilsResponse;
import net.wimpi.modbus.msg.ReadInputDiscretesRequest;
import net.wimpi.modbus.msg.ReadInputDiscretesResponse;
import net.wimpi.modbus.msg.ReadInputRegistersRequest;
import net.wimpi.modbus.msg.ReadInputRegistersResponse;
import net.wimpi.modbus.msg.ReadMultipleRegistersRequest;
import net.wimpi.modbus.msg.ReadMultipleRegistersResponse;
import net.wimpi.modbus.msg.WriteMultipleRegistersRequest;
import net.wimpi.modbus.msg.WriteMultipleRegistersResponse;
import net.wimpi.modbus.msg.WriteSingleRegisterRequest;
import net.wimpi.modbus.msg.WriteSingleRegisterResponse;
import net.wimpi.modbus.net.SerialConnection;
import net.wimpi.modbus.net.TCPMasterConnection;
import net.wimpi.modbus.procimg.Register;
import net.wimpi.modbus.procimg.SimpleRegister;
import net.wimpi.modbus.util.SerialParameters;
/**
 * This class realizes modbus protocol
 * communication over TCP and Serial Port and most of modbus functions.
 *
 * @author Tomas Ausvicas
 */
public class BackEnd {
/** The tcp con. */
 TCPMasterConnection tcpCon;
  
 /** The serial con. */
  SerialConnection serialCon;
/** The transaction tcp. */
 ModbusTCPTransaction transactionTCP;
 
 /** The transaction serial. */
 ModbusSerialTransaction transactionSerial;
/** The params. */
 SerialParameters params = new SerialParameters();
/** The rcreq. */
  ReadCoilsRequest rcreq = new ReadCoilsRequest();
 
 /** The rcres. */
ReadCoilsResponse rcres = new ReadCoilsResponse();
/** The rireq. */
ReadInputRegistersRequest rireq = new ReadInputRegistersRequest();
 
 /** The rires. */
 ReadInputRegistersResponse rires = new ReadInputRegistersResponse();
/** The ridreq. */
  ReadInputDiscretesRequest ridreq = new ReadInputDiscretesRequest();
 
 /** The ridres. */
 ReadInputDiscretesResponse ridres = new ReadInputDiscretesResponse();
/** The write_sreq. */
  WriteSingleRegisterRequest write_sreq = new WriteSingleRegisterRequest();
 
 /** The write_sres. */
 WriteSingleRegisterResponse write_sres = new WriteSingleRegisterResponse();
/** The read_mreq. */
  ReadMultipleRegistersRequest read_mreq = new ReadMultipleRegistersRequest();
 
 /** The read_mres. */
 ReadMultipleRegistersResponse read_mres = new `ReadMultipleRegistersResponse();`
/** The write_mreq. */
  WriteMultipleRegistersRequest write_mreq = new WriteMultipleRegistersRequest();
 
 /** The write_mres. */
 WriteMultipleRegistersResponse write_mres = new WriteMultipleRegistersResponse();
/** The register. */
 SimpleRegister regL, regH, register;
 
 /** The registers. */
 Register[] registers;
/** The int16 result. */
 private int[] int16Result;
 
 /** The int32 result. */
 private int[] int32Result;
 
 /** The float result. */
 private float[] floatResult;
 
 /** The round float result. */
 private float[] roundFloatResult;
/** The string16 result. */
 private String[] string16Result;
 
 /** The string32 result. */
 private String[] string32Result;
 
 /** The string float result. */
 private String[] stringFloatResult;
 
 /** The round string float result. */
 private String[] roundStringFloatResult;
/** The string coil result. */
 private String[] stringCoilResult;
 
 /** The boolean coil result. */
 private boolean[] booleanCoilResult;
/** The string discrete input result. */
 private String[] stringDiscreteInputResult;
 
 /** The boolean discrete input result. */
 private boolean[] booleanDiscreteInputResult;
/** The string read bit result. */
  private String[] stringReadBitResult;
 
 /** The boolean read bit result. */
 private boolean[] booleanReadBitResult;
/** The int analog input registers result. */
  private int[] intAnalogInputRegistersResult;
 
 /** The string analog input registers result. */
 private String[] stringAnalogInputRegistersResult;
/** The to string. */
private String[] toString;
/**  * Default constructor with TCP and Serial Port objects created. */
  public BackEnd() {
  try {
 tcpCon = new TCPMasterConnection(InetAddress.getByName(""));
  } catch (UnknownHostException e) {
  System.out.println("Unknow Host");
 }
 params = new SerialParameters();
 serialCon = new SerialConnection(params);
 }
/**  * Connect over TCP. *
 * @param ipAddress the ip address
 * @param port the port
 */
  public void connectTCP(String ipAddress, int port) {
  try {
 tcpCon = new TCPMasterConnection(InetAddress.getByName(ipAddress));
  } catch (UnknownHostException e1) {
 JOptionPane.showMessageDialog(null, "Įveskite IP adresą", "Invalid input", JOptionPane.WARNING_MESSAGE);
 }
 tcpCon.setPort(port);
 try {
 tcpCon.connect();
 } catch (Exception e) {
 JOptionPane.showMessageDialog(null, "Nepavyko prisijungti prie serverio. [TCP/IP]", "Connection error",
  JOptionPane.ERROR_MESSAGE);
 }
 
 transactionTCP = new ModbusTCPTransaction(tcpCon);
 
 }
/**  * Set parameters for serial com. *
 * @param portName the port name
 * @param baudRate the baud rate
 * @param dataBits the data bits
 * @param stopBits the stop bits
 * @param parity the parity
 * @param encoding the encoding
 * @param echo the echo
 */
  public void connectSerial(String portName, int baudRate, int dataBits, int stopBits, String parity, String encoding,
 boolean echo) {
  SerialParameters params = new SerialParameters();
  params.setPortName(portName);
  params.setDatabits(dataBits);
  params.setParity(parity);
 params.setStopbits(stopBits);
 params.setEncoding(encoding);
 params.setEcho(echo);
 params.setBaudRate(baudRate);
  serialCon = new SerialConnection(params);
  try {
 serialCon.open();
  } catch (Exception e) {
  JOptionPane.showMessageDialog(null, "Nepavyko prisijungti prie serverio. [Serial port]", "Connection error",
 JOptionPane.ERROR_MESSAGE);
 }
 transactionSerial = new ModbusSerialTransaction(serialCon);
 }
/** * Close TCP connection. */
  public void closeTCP() {
 tcpCon.close();
 }
/** * Close Serial connection. */
  public void closeSerial() {
 serialCon.close();
 }
/** * Check if TCP connected. *
 * @return boolean value
 */
  public boolean isConnectedTCP() {
 return tcpCon.isConnected();
 
 }
/** * Check if Serial connected. *
 * @return boolean value
 */
  public boolean isOpenSerial() {
 return serialCon.isOpen();
 }
/** * Writes single 16bit number to register (16 bit integer).
 *
  * @param unitID the unit id
 * @param startAddress the start address
 * @param dataToWrite the data to write
 */
  public void WriteSingle_16Bit(int unitID, int startAddress, int dataToWrite) {
 SimpleRegister reg = new SimpleRegister(dataToWrite);
  write_sreq.setReference(startAddress);
  write_sreq.setUnitID(unitID);
  write_sreq.setRegister(reg);
 try {
  transaction(transactionTCP, transactionSerial, write_sreq);
 } catch (ModbusIOException e) {
 System.out.println("Modbus IO Exception write 16");
  } catch (ModbusSlaveException e) {
  System.out.println("Modbus Slave Exception write 16");
  } catch (ModbusException e) {
 System.out.println("Modbus Exception write 16");
 }
 }
  /**
 * Writes double 16bit number to register (32 bit integer).
  *
 * @param unitID the unit id
 * @param startAddress the start address
  * @param dataToWrite the data to write
  */
 public void WriteSingle_32Bit(int unitID, int startAddress, int dataToWrite) {
 int count = 2;
 int HIGH = dataToWrite >> 16;
 int LOW = dataToWrite & 0xFFFF;
 regH = new SimpleRegister(HIGH);
 regL = new SimpleRegister(LOW);
  registers = new Register[count];
 for (int i = 0, a = 1; i < registers.length; i += 2, a += 2) {
  registers[i] = regL;
  registers[a] = regH;
  }
  write_mreq.setReference(startAddress);
 write_mreq.setUnitID(unitID);
 write_mreq.setRegisters(registers);
 try {
  transaction(transactionTCP, transactionSerial, write_mreq);
 } catch (ModbusIOException e) {
  System.out.println("Modbus IO Exception write 32");
 } catch (ModbusSlaveException e) {
 System.out.println("Modbus Slave Exception write 32");
 } catch (ModbusException e) {
  System.out.println("Modbus Exception write 32");
 }
 }
/**
 * Writes double 16bit number to register (32bit float).
 *
 * @param unitID the unit id
 * @param startAddress the start address
 * @param dataToWriteF the data to write f
 */
public void WriteSingle_Float(int unitID, int startAddress, float dataToWriteF) {
 int count = 2;
  int number = Float.floatToIntBits(dataToWriteF);
 int HIGH = number >> 16;
 int LOW = number & 0xFFFF;
 regH = new SimpleRegister(HIGH);
 regL = new SimpleRegister(LOW);
 registers = new Register[count];
 for (int i = 1, a = 0; i < registers.length; i += 2, a += 2) {
 registers[i] = regL;
 registers[a] = regH;
 }
  write_mreq.setReference(startAddress);
  write_mreq.setUnitID(unitID);
  write_mreq.setRegisters(registers);
 try {
 transaction(transactionTCP, transactionSerial, write_mreq);
 } catch (ModbusIOException e) {
 System.out.println("Modbus IO Exception write float");
 } catch (ModbusSlaveException e) {
 System.out.println("Modbus Slave Exception write float");
 } catch (ModbusException e) {
 System.out.println("Modbus Exception write float");
 }
 }
 /**
 * Writes multiple 16bit numbers to chosen registers (16bit integer).
 *
 * @param unitID the unit id
 * @param startAddress the start address
 * @param dataToWrite the data to write
 * @param count the count
 */
 public void WriteMultiple_16Bit(int unitID, int startAddress, int dataToWrite, int count) {
 register = new SimpleRegister(dataToWrite);
 registers = new Register[count];
  for (int i = 0; i < registers.length; i++) {
 registers[i] = register;
  }
  write_mreq.setReference(startAddress);
 write_mreq.setUnitID(unitID);
 write_mreq.setRegisters(registers);
 try {
 transaction(transactionTCP, transactionSerial, write_mreq);
  } catch (ModbusIOException e) {
 System.out.println("Modbus IO Exception mwrite 16");
  } catch (ModbusSlaveException e) {
  System.out.println("Modbus Slave Exception mwrite 16");
 } catch (ModbusException e) {
 System.out.println("Modbus Exception mwrite 16");
 }
 }
 /**
 * Writes multiple double 16bit numbers to chosen registers (32bit integer).
 *
 * @param unitID the unit id
 * @param startAddress the start address
 * @param dataToWrite the data to write
 * @param count the count
 */
  public void WriteMultiple_32Bit(int unitID, int startAddress, int dataToWrite, int count) {
 int HIGH = dataToWrite >> 16;
 int LOW = dataToWrite & 0xFFFF;
 regH = new SimpleRegister(HIGH);
 regL = new SimpleRegister(LOW);
 registers = new Register[count * 2];
  for (int i = 0, a = 1; i < registers.length; i += 2, a += 2) {
 registers[i] = regL;
  registers[a] = regH;
 }
  write_mreq.setReference(startAddress);
 write_mreq.setUnitID(unitID);
 write_mreq.setRegisters(registers);
 try {
 transaction(transactionTCP, transactionSerial, write_mreq);
  } catch (ModbusIOException e) {
 System.out.println("Modbus IO Exception mwrite 32");
  } catch (ModbusSlaveException e) {
  System.out.println("Modbus Slave Exception mwrite 32");
 } catch (ModbusException e) {
 System.out.println("Modbus Exception mwrite 32");
 }
 }
 /**
 * Writes multiple double 16bit numbers to chosen registers (32bit float).
  *
 * @param unitID the unit id
  * @param startAddress the start address
 * @param dataToWriteF the data to write f
 * @param count the count
 */
 public void WriteMultiple_Float(int unitID, int startAddress, float dataToWriteF, int count) {
 int number = Float.floatToIntBits(dataToWriteF);
 int HIGH = number >> 16;
 int LOW = number & 0xFFFF;
 regH = new SimpleRegister(HIGH);
 regL = new SimpleRegister(LOW);
 registers = new Register[count * 2];
 for (int i = 1, a = 0; i < registers.length; i += 2, a += 2) {
 registers[i] = regL;
 registers[a] = regH;
 }
 write_mreq.setReference(startAddress);
 write_mreq.setUnitID(unitID);
 write_mreq.setRegisters(registers);
 try {
 transaction(transactionTCP, transactionSerial, write_mreq);
 } catch (ModbusIOException e) {
 System.out.println("Modbus IO Exception mwrite float");
 } catch (ModbusSlaveException e) {
 System.out.println("Modbus Slave Exception mwrite float");
 } catch (ModbusException e) {
 System.out.println("Modbus Exception mwrite float");
 }
 }
/**
 * Reads multiple 16bit numbers from chosen registers (16bit integer).
 *
 * @param unitID the unit id
 * @param startAddress the start address
 * @param count the count
 * @return multiple registers
 */
public BackEnd ReadMultiple_16Bit(int unitID, int startAddress, int count) {
 this.int16Result = new int[count];
 this.string16Result = new String[count];
  read_mreq.setUnitID(unitID);
  read_mreq.setReference(startAddress);
 read_mreq.setWordCount(count);
 try {
 transaction(transactionTCP, transactionSerial, read_mreq);
 } catch (ModbusIOException e) {
 System.out.println("Modbus IO Exception mread 16");
 } catch (ModbusSlaveException e) {
 System.out.println("Modbus Slave Exception mread 16");
 } catch (ModbusException e) {
 System.out.println("Modbus Exception mread 16");
 }
 for (int n = 0; n < read_mres.getWordCount(); n++) {
 int16Result[n] = read_mres.getRegisterValue(n);
 string16Result[n] = String.valueOf(int16Result[n]);
 }
 return this;
 }
/**
 * Reads multiple double 16bit numbers from chosen registers (32bit integer).
 *
 * @param unitID the unit id
 * @param startAddress the start address
 * @param count the count
 * @return multiple registers
 */
public BackEnd ReadMultiple_32Bit(int unitID, int startAddress, int count) {
 this.int32Result = new int[count];
 this.string32Result = new String[count];
 int[] z = new int[count * 2];
 int[] y = new int[count * 2];
  int[] h = new int[count];
  int[] l = new int[count];
 read_mreq.setUnitID(unitID);
 read_mreq.setReference(startAddress);
 read_mreq.setWordCount(count * 2);
  try {
 transaction(transactionTCP, transactionSerial, read_mreq);
 } catch (ModbusIOException e) {
 System.out.println("Modbus IO Exception mread 32");
  } catch (ModbusSlaveException e) {
 System.out.println("Modbus Slave Exception mread 32");
  } catch (ModbusException e) {
 System.out.println("Modbus Exception mread 32");
 }
 for (int n = 0, i = 1; n < read_mres.getWordCount(); n += 2, i += 2) {
 z[n] = read_mres.getRegisterValue(n);
 y[i] = (read_mres.getRegisterValue(i) << 16);
 }
 for (int a = 0, b = 0; a < l.length; a++, b += 2) {
  l[a] = z[b];
 }
 for (int a = 0, b = 1; a < h.length; a++, b += 2) {
 h[a] = y[b];
  }
  for (int n = 0; n < int32Result.length; n++) {
  int32Result[n] = h[n] | l[n];
 string32Result[n] = String.valueOf(int32Result[n]);
 }
 return this;
 }
 /**
 * Reads multiple double 16bit numbers from chosen registers (32 bit float).
  *
 * @param unitID the unit id
 * @param startAddress the start address
 * @param count the count
  * @return multiple registers
 */
 public BackEnd ReadMultiple_Float(int unitID, int startAddress, int count) {
  this.floatResult = new float[count];
 this.stringFloatResult = new String[count];
 this.roundFloatResult = new float[count];
 this.roundStringFloatResult = new String[count];
 int[] x = new int[count * 2];
 int[] y = new int[count * 2];
 int[] h = new int[count];
 int[] l = new int[count];
 read_mreq.setUnitID(unitID);
  read_mreq.setReference(startAddress);
 read_mreq.setWordCount(count * 2);
 try {
  transaction(transactionTCP, transactionSerial, read_mreq);
 } catch (ModbusIOException e) {
 System.out.println("Modbus IO Exception mread float");
 } catch (ModbusSlaveException e) {
 System.out.println("Modbus Slave Exception mread float");
 } catch (ModbusException e) {
 System.out.println("Modbus Exception mread float");
 }
  for (int n = 1, i = 0; n < read_mres.getWordCount(); n += 2, i += 2) {
  x[n] = read_mres.getRegisterValue(n);
  y[i] = (read_mres.getRegisterValue(i) << 16);
 }
 for (int a = 0, b = 1; a < l.length; a++, b += 2) {
 l[a] = x[b];
 }
 for (int a = 0, b = 0; a < h.length; a++, b += 2) {
 h[a] = y[b];
 }
 for (int n = 0; n < floatResult.length; n++) {
  floatResult[n] = Float.intBitsToFloat(h[n] | l[n]);
  stringFloatResult[n] = String.valueOf(floatResult[n]);
  roundFloatResult[n] = (float) Math.round(floatResult[n] * 100) / 100;
 roundStringFloatResult[n] = Float.toString(roundFloatResult[n]);
 }
 return this;
 }
 /**
 * Reads multiple coils from chosen registers.  *
 * @param unitID the unit id
  * @param startAddress the start address
 * @param count the count
 * @return coil as boolean or String
  */
 public BackEnd ReadCoilStatus(int unitID, int startAddress, int count) {
  this.booleanCoilResult = new boolean[count];
 this.stringCoilResult = new String[count];
 rcreq.setReference(startAddress);
 rcreq.setBitCount(count);
 rcreq.setUnitID(unitID);
  try {
  transaction(transactionTCP, transactionSerial, rcreq);
 } catch (ModbusIOException e) {
 e.printStackTrace();
  } catch (ModbusSlaveException e) {
  e.printStackTrace();
  } catch (ModbusException e) {
  e.printStackTrace();
  }
  for (int i = 0; i < count; i++) {
 booleanCoilResult[i] = rcres.getCoilStatus(i);
  stringCoilResult[i] = String.valueOf(booleanCoilResult[i]);
 }
 return this;
 }
 /**
 * Reads multiple discrete inputs from chosen registers.
 *
 * @param unitID the unit id
  * @param startAddress the start address
  * @param count the count
  * @return discrete input as boolean or String
 */
 public BackEnd ReadDiscreteInputStatus(int unitID, int startAddress, int count) {
 this.booleanDiscreteInputResult = new boolean[count];
 this.stringDiscreteInputResult = new String[count];
 ridreq.setReference(startAddress);
 ridreq.setBitCount(count);
 ridreq.setUnitID(unitID);
 try {
 transaction(transactionTCP, transactionSerial, ridreq);
  } catch (ModbusIOException e) {
 e.printStackTrace();
  } catch (ModbusSlaveException e) {
  e.printStackTrace();
 } catch (ModbusException e) {
 e.printStackTrace();
  }
 for (int i = 0; i < count; i++) {
  booleanDiscreteInputResult[i] = ridres.getDiscreteStatus(i);
 stringDiscreteInputResult[i] = String.valueOf(booleanDiscreteInputResult[i]);
 }
 return this;
 }
 /**
  * Reads multiple analog inputs from chosen registers.
 *
 * @param unitID the unit id
 * @param startAddress the start address
 * @param count the count
 * @return analog input register value (int or String)
 */
 public BackEnd ReadAnalogInputRegisters(int unitID, int startAddress, int count) {
 this.intAnalogInputRegistersResult = new int[count];
 this.stringAnalogInputRegistersResult = new String[count];
  rireq.setReference(startAddress);
  rireq.setWordCount(count);
  rireq.setUnitID(unitID);
  try {
 transaction(transactionTCP, transactionSerial, rireq);
 } catch (ModbusIOException e) {
 e.printStackTrace();
  } catch (ModbusSlaveException e) {
 e.printStackTrace();
  } catch (ModbusException e) {
 e.printStackTrace();
 }
 for (int i = 0; i < count; i++) {
 intAnalogInputRegistersResult[i] = rires.getRegisterValue(i);
 stringAnalogInputRegistersResult[i] = String.valueOf(intAnalogInputRegistersResult[i]);
 }
 return this;
 }
 /**
 * Read bit from a register.
 *
 * @param unitID the unit id
 * @param startAddress the start address
 * @param position  D15..D0
 * @param count the count
 * @return bit as boolean or String
 */
public BackEnd ReadBit(int unitID, int startAddress, int position, int count) {
 this.stringReadBitResult = new String[count];
  this.booleanReadBitResult = new boolean[count];
 this.toString = new String[count];
 // String[] toString = new String[count];
 read_mreq.setUnitID(unitID);
 read_mreq.setReference(startAddress);
 read_mreq.setWordCount(count);
  try {
  transaction(transactionTCP, transactionSerial, read_mreq);
  } catch (ModbusIOException e) {
  System.out.println("Modbus IO Exception read bit");
 } catch (ModbusSlaveException e) {
 System.out.println("Modbus Slave Exception read bit");
 } catch (ModbusException e) {
 System.out.println("Modbus Exception read bit");
 }
  for (int n = 0; n < read_mres.getWordCount(); n++) {
 try {
 toString[n] = Integer.toBinaryString(0x10000 | read_mres.getRegisterValue(n)).substring(1);
  if (toString[n].charAt(15 - position) == '0') {
 booleanReadBitResult[n] = false;
  stringReadBitResult[n] = String.valueOf(false);
  } else if (toString[n].charAt(15 - position) == '1') {
  booleanReadBitResult[n] = true;
  stringReadBitResult[n] = String.valueOf(true);
 }
 } catch (IndexOutOfBoundsException e) {
  }
  }
 return this;
 }
 /**
 * Write bit to a register.
 *
 * @param unitID the unit id
 * @param startAddress the start address
 * @param position D15..D0
  * @param bitas true=0, false=1
 * @param count the count
 */
 public void WriteBit(int unitID, int startAddress, int position, boolean bitas, int count) {
  String value = "";
 if (bitas == true) {
 value = "1";
 } else if (bitas == false) {
 value = "0";
  }
 int[] x = new int[count];
 String[] toString = new String[count];
  String[] Format16Bit = new String[count];
 read_mreq.setUnitID(unitID);
  read_mreq.setReference(startAddress);
 read_mreq.setWordCount(count);
 try {
 transaction(transactionTCP, transactionSerial, read_mreq);
 } catch (ModbusIOException e) {
 System.out.println("Modbus IO Exception Readwrite bit");
  } catch (ModbusSlaveException e) {
 System.out.println("Modbus Slave Exception Readwrite bit");
  } catch (ModbusException e) {
 System.out.println("Modbus Exception Readwrite bit");
 }
 for (int n = 0; n < read_mres.getWordCount(); n++) {
 toString[n] = Integer.toBinaryString(0x10000 | read_mres.getRegisterValue(n)).substring(1);
 }
 registers = new Register[count];
 for (int n = 0; n < count; n++) {
 Format16Bit[n] = toString[n].substring(0, 15 - position) + value + toString[n].substring(15 - position + 1);
 x[n] = Integer.parseInt(Format16Bit[n], 2);
 register = new SimpleRegister(x[n]);
 registers[n] = register;
 }
 write_mreq.setReference(startAddress);
 write_mreq.setRegisters(registers);
 write_mreq.setUnitID(unitID);
 try {
 transaction(transactionTCP, transactionSerial, write_mreq);
 } catch (ModbusIOException e) {
 System.out.println("Modbus IO Exception Write bit");
 } catch (ModbusSlaveException e) {
 System.out.println("Modbus Slave Exception Write bit");
 } catch (ModbusException e) {
 System.out.println("Modbus Exception Write bit");
 }
 }
 /**
  * Overloading method for transaction over modbus protocol.
 *
 * @param transactionTCP the transaction tcp
 * @param transactionSerial the transaction serial
 * @param write_mreq the write_mreq
 * @throws ModbusIOException the modbus io exception
 * @throws ModbusSlaveException the modbus slave exception
 * @throws ModbusException the modbus exception
 */
 public void transaction(ModbusTCPTransaction transactionTCP, ModbusSerialTransaction transactionSerial,
 WriteMultipleRegistersRequest write_mreq) throws ModbusIOException, ModbusSlaveException, ModbusException {
  try {
 transactionTCP.setRequest(write_mreq);
 transactionTCP.execute();
 transactionTCP.getResponse();
 } catch (Exception e) {
 System.out.println("[TCP] write_mreq error");
 }
 try {
  transactionSerial.setRequest(write_mreq);
 transactionSerial.execute();
  transactionSerial.getResponse();
  } catch (Exception e) {
  System.out.println("[Serial] write_mreq error");
 }

 }
 /**
  * Overloading method.
 *
  * @param transactionTCP the transaction tcp
 * @param transactionSerial the transaction serial
 * @param write_sreq the write_sreq
 * @throws ModbusIOException the modbus io exception
 * @throws ModbusSlaveException the modbus slave exception
 * @throws ModbusException the modbus exception
 */
 public void transaction(ModbusTCPTransaction transactionTCP, ModbusSerialTransaction transactionSerial,
  WriteSingleRegisterRequest write_sreq) throws ModbusIOException, ModbusSlaveException, ModbusException {
 try {
 transactionTCP.setRequest(write_sreq);
 transactionTCP.execute();
 transactionTCP.getResponse();
 } catch (Exception e) {
 System.out.println("[TCP] write_sreq error");
 }
 try {
  transactionSerial.setRequest(write_sreq); transactionSerial.execute();
  transactionSerial.getResponse();
 } catch (Exception e) {
 System.out.println("[Serial] write_sreq error");
 }
 }
 /**
  * Overloading method.
 *
 * @param transactionTCP the transaction tcp
 * @param transactionSerial the transaction serial
 * @param read_mreq the read_mreq
 * @throws ModbusIOException the modbus io exception
 * @throws ModbusSlaveException the modbus slave exception
 * @throws ModbusException the modbus exception
 */
 public void transaction(ModbusTCPTransaction transactionTCP, ModbusSerialTransaction transactionSerial,
 ReadMultipleRegistersRequest read_mreq) throws ModbusIOException, ModbusSlaveException, ModbusException {
  try {
 transactionTCP.setRequest(read_mreq);
  transactionTCP.execute();
  read_mres = (ReadMultipleRegistersResponse) transactionTCP.getResponse();
 } catch (Exception e) {
 System.out.println("[TCP] read_mreq error");
 }
 try {
 
  transactionSerial.setRequest(read_mreq);
 transactionSerial.execute();
 read_mres = (ReadMultipleRegistersResponse) transactionSerial.getResponse();
 } catch (Exception e) {
 System.out.println("[Serial] read_mreq error");
 }
 }
/**
 * Overloading method.
 *
 * @param transactionTCP the transaction tcp
 * @param transactionSerial the transaction serial
 * @param rcreq the rcreq
 * @throws ModbusIOException the modbus io exception
 * @throws ModbusSlaveException the modbus slave exception
 * @throws ModbusException the modbus exception
 */
public void transaction(ModbusTCPTransaction transactionTCP, ModbusSerialTransaction transactionSerial,
  ReadCoilsRequest rcreq) throws ModbusIOException, ModbusSlaveException, ModbusException {
 try {
 transactionTCP.setRequest(rcreq);
 transactionTCP.execute();
 rcres = (ReadCoilsResponse) transactionTCP.getResponse();
 } catch (Exception e) {
 System.out.println("[TCP] rcreq error");
 }
 try {
 transactionSerial.setRequest(rcreq);
 transactionSerial.execute();
 rcres = (ReadCoilsResponse) transactionSerial.getResponse();
 } catch (Exception e) {
 System.out.println("[Serial] rcreq error");
 }
 }
 /**
 * Overloading method.
 *
 * @param transactionTCP the transaction tcp
 * @param transactionSerial the transaction serial
 * @param rireq the rireq
 * @throws ModbusIOException the modbus io exception
 * @throws ModbusSlaveException the modbus slave exception
 * @throws ModbusException the modbus exception
 */
 public void transaction(ModbusTCPTransaction transactionTCP, ModbusSerialTransaction transactionSerial,
 ReadInputRegistersRequest rireq) throws ModbusIOException, ModbusSlaveException, ModbusException {
  try {
  transactionTCP.setRequest(rireq);
  transactionTCP.execute();
  rires = (ReadInputRegistersResponse) transactionTCP.getResponse();
 } catch (Exception e) {
 System.out.println("[TCP] rireq error");
 }
 try {
  transactionSerial.setRequest(rireq);
  transactionSerial.execute();
  rires = (ReadInputRegistersResponse) transactionSerial.getResponse();
 } catch (Exception e) {
 System.out.println("[Serial] rireq error");
 }
 }
 /**
 * Overloading method.
 *
 * @param transactionTCP the transaction tcp
 * @param transactionSerial the transaction serial
 * @param ridreq the ridreq
 * @throws ModbusIOException the modbus io exception
 * @throws ModbusSlaveException the modbus slave exception
  * @throws ModbusException the modbus exception
 */
 public void transaction(ModbusTCPTransaction transactionTCP, ModbusSerialTransaction transactionSerial,
 ReadInputDiscretesRequest ridreq) throws ModbusIOException, ModbusSlaveException, ModbusException {
  try {
  transactionTCP.setRequest(ridreq);
  transactionTCP.execute();
  ridres = (ReadInputDiscretesResponse) transactionTCP.getResponse();
 } catch (Exception e) {
 System.out.println("[TCP] ridreq error");
 }
 try {
  transactionSerial.setRequest(ridreq);
  transactionSerial.execute();
 ridres = (ReadInputDiscretesResponse) transactionSerial.getResponse();
 } catch (Exception e) {
 System.out.println("[Serial] ridreq error");
 }
 }
 /**
 * Gets the 16 bit int.
 *
 * @return 16bit numbers as int array
  */
 public int[] get16BitInt() {
 return int16Result;
 }
 /**
 * Gets the 32 bit int.
 *
 * @return 32bit numbers as int array
 */
 public int[] get32BitInt() {
 return int32Result;
 }
 /**
 * Gets the float.
 *
 * @return 32bit float numbers as float array
  */
 public float[] getFloat() {
 return floatResult;
 }
 /**
 * Gets the round float.
 *
 * @return 32bit float numbers as rounded float array
  */
 public float[] getRoundFloat() {
 return roundFloatResult;
 }
 /**
 * Gets the 16 bit string.
 *
 * @return 16bit numbers as String array
  */
 public String[] get16BitString() {
 return string16Result;
 }
 /**
 * Gets the 32 bit string.
 *
 * @return 32bit numbers as String array
 */
 public String[] get32BitString() {
 return string32Result;
 }
 /**
 * Gets the float string.
 *
 * @return 32bit float numbers as String array
 */
 public String[] getFloatString() {
 return stringFloatResult;
 }
/**
 * Gets the round float string.
 *
 * @return 32bit float numbers as rounded String array
 */
public String[] getRoundFloatString() {
 return roundStringFloatResult;
}
/**
 * Gets the 16 bit at index.
 *
 * @param index the index
 * @return 16bit number from int array at index
 */
public int get16BitAtIndex(int index) {
 return int16Result[index];
}
/**
 * Gets the 32 bit at index.
 *
 * @param index the index
 * @return 32bit number from int array at index
 */
public int get32BitAtIndex(int index) {
 return int32Result[index];
}
/**
 * Gets the float at index.
 *
 * @param index the index
 * @return 32bit foat number from float array at index
 */
public float getFloatAtIndex(int index) {
 return floatResult[index];
}
/**
 * Gets the round float at index.
 *
 * @param index the index
 * @return 32bit rounded float number from rounded float array at index
 */
public float getRoundFloatAtIndex(int index) {
 return roundFloatResult[index];
}
/**
 * Gets the 16 bit string at index.
 *
 * @param index the index
 * @return 16bit rounded float number from rounded String array at index
 */
public String get16BitStringAtIndex(int index) {
 return string16Result[index];
}
/**
 * Gets the 32 bit string at index.
 *
 * @param index the index
 * @return 32bit number from String array at index
 */
public String get32BitStringAtIndex(int index) {
 return string32Result[index];
}
/**
 * Gets the float string at index.
 *
 * @param index the index
 * @return 32bit float number from String array at index
 */
public String getFloatStringAtIndex(int index) {
 return stringFloatResult[index];
}
/**
 * Gets the round float string at index.
 *
 * @param index the index
 * @return 32bit rounded float number from rounded String array at index
 */
public String getRoundFloatStringAtIndex(int index) {
 return roundStringFloatResult[index];
}
/**
 * Gets the coil boolean at index.
 *
 * @param index the index
 * @return coil status from boolean array at index
 */
public Boolean getCoilBooleanAtIndex(int index) {
 return booleanCoilResult[index];
}
/**
 * Gets the coil string at index.
 *
 * @param index the index
 * @return coil status from String array at index
 */
public String getCoilStringAtIndex(int index) {
 return stringCoilResult[index];
}
/**
 * Gets the coil boolean.
 *
 * @return coil status from boolean array
 */
public boolean[] getCoilBoolean() {
 return booleanCoilResult;
}
/**
 * Gets the coil string.
 *
 * @return coil status from String array
 */
public String[] getCoilString() {
 return stringCoilResult;
}
/**
 * Gets the read bit boolean.
 *
 * @return bit status from boolean array
 */
public boolean[] getReadBitBoolean() {
 return booleanReadBitResult;
}
/**
 * Gets the read bit boolean at index.
 *
 * @param index the index
 * @return bit status from boolean array at index
 */
public boolean getReadBitBooleanAtIndex(int index) {
 return booleanReadBitResult[index];
}
/**
 * Gets the read bit string.
 *
 * @return bit status from String array
 */
public String[] getReadBitString() {
 return stringReadBitResult;
}
/**
 * Gets the read bit string bin.
 *
 * @return String binary format (01010101..)
 */
public String[] getReadBitStringBin() {
 StringBuilder[] str = new StringBuilder[toString.length];
 for (int i = 0; i < str.length; i++) {
 str[i] = new StringBuilder(toString[i]);
 int idx = str[i].length() - 4;
 while (idx > 0) {
 str[i].insert(idx, " ");
 toString[i] = str[i].toString();
 idx = idx - 4;
 }
 }
 return toString;
 }
/**
 * Gets the read bit string at index.
 *
 * @param index the index
 * @return bit status from String array at index
 */
public String getReadBitStringAtIndex(int index) {
 return stringReadBitResult[index];
}
/**
 * Gets the boolean discrete input result.
 *
 * @return dicrete input status from boolean array
 */
public boolean[] getBooleanDiscreteInputResult() {
 return booleanDiscreteInputResult;
}
/**
 * Gets the boolean discrete input result at index.
 *
 * @param index the index
 * @return dicrete input status from boolean array at index
 */
public boolean getBooleanDiscreteInputResultAtIndex(int index) {
 return booleanDiscreteInputResult[index];
}
/**
 * Gets the string discrete input result.
 *
 * @return dicrete input status from String array
 */
public String[] getStringDiscreteInputResult() {
 return stringDiscreteInputResult;
}
/**
 * Gets the string discrete input result at index.
 *
 * @param index the index
 * @return dicrete input status from String array at index
 */
public String getStringDiscreteInputResultAtIndex(int index) {
 return stringDiscreteInputResult[index];
}
/**
 * Gets the int analog input registers result.
 *
 * @return analog input status from int array
 */
public int[] getIntAnalogInputRegistersResult() {
 return intAnalogInputRegistersResult;
}
/**
 * Gets the int analog input registers result at index.
 *
 * @param index the index
 * @return analog input status from int array at index
 */
public int getIntAnalogInputRegistersResultAtIndex(int index) {
 return intAnalogInputRegistersResult[index];
}
/**
 * Gets the string analog input registers result.
 *
 * @return analog input status from String array
 */
public String[] getStringAnalogInputRegistersResult() {
 return stringAnalogInputRegistersResult;
}
/**
 * Gets the string analog input registers result at index.
 *
 * @param index the index
 * @return analog input status from String array at index
 */
public String getStringAnalogInputRegistersResultAtIndex(int index) {
 return stringAnalogInputRegistersResult[index];
 }
}