j2mod

https://github.com/steveohara/j2mod
Admin
j2mod is a refactored and production-ready Java library for Modbus communication, supporting Modbus...
Tokens:58,399
Snippets:666
Trust Score:6.9
License:Apache-2.0
Update:2 months ago
Show doc for...
Tokens:
Raw
### Complete Modbus TCP Slave Setup Example

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/ModbusSlave.md

Demonstrates the complete setup of a Modbus TCP slave, including creation, process image configuration, and starting the slave. This example requires importing necessary classes from j2mod.modbus.

```java
import com.ghgande.j2mod.modbus.slave.*;
import com.ghgande.j2mod.modbus.procimg.*;

// Create TCP slave on port 502 with 5 worker threads
ModbusSlave slave = ModbusSlaveFactory.createTCPSlave(502, 5);

// Create and configure process image
ProcessImage image = new SimpleProcessImage();
for (int i = 0; i < 100; i++) {
    image.getRegister(i).setValue(i * 10);
}
for (int i = 0; i < 16; i++) {
    image.getDigitalOut(i).set(i % 2 == 0);
}

// Register image for unit ID 1
slave.addProcessImage(1, image);

// Start listening
slave.open();
System.out.println("Slave running on port " + slave.getPort());

// Clean up when done
try {
    Thread.sleep(10000);
} finally {
    slave.close();
}
```

--------------------------------

### open()

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/ModbusSlave.md

Starts the slave listener thread and begins accepting client connections. This method must be called after the slave has been configured.

```APIDOC
## open()

### Description
Starts the slave listener thread and begins accepting client connections. Must be called after configuring the slave.

### Method
void

### Parameters
None

### Throws
None (check `getError()` for startup failures)

### Example
```java
ModbusSlave slave = ModbusSlaveFactory.createTCPSlave(502, 5);
ProcessImage image = new SimpleProcessImage();
slave.addProcessImage(1, image);
slave.open();
System.out.println("Slave started on port " + slave.getPort());
```
```

--------------------------------

### Read Input Registers Example

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/Register.md

Reads a range of input registers and prints their unsigned integer values.

```java
InputRegister[] regs = master.readInputRegisters(0, 10);
for (InputRegister reg : regs) {
    int value = reg.getValue();
    System.out.println("Value: " + value);
}
```

--------------------------------

### Simple TCP Master Read Example

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/README.md

Demonstrates how to establish a TCP connection, read multiple registers, and handle disconnection. Ensure ModbusTCPMaster is imported.

```java
ModbusTCPMaster master = new ModbusTCPMaster("192.168.1.100");
master.connect();
try {
    Register[] regs = master.readMultipleRegisters(0, 10);
    for (Register reg : regs) {
        System.out.println(reg.getValue());
    }
} finally {
    master.disconnect();
}
```

--------------------------------

### Simple Serial Master (ASCII Mode) Setup

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/SerialParameters.md

Demonstrates setting up a ModbusSerialMaster in ASCII mode with basic serial parameters and performing a read operation.

```java
SerialParameters params = new SerialParameters("COM1", 19200);
params.setEncoding("ascii");

ModbusSerialMaster master = new ModbusSerialMaster(params);
master.connect();
try {
    Register[] regs = master.readMultipleRegisters(0, 10);
} finally {
    master.disconnect();
}
```

--------------------------------

### RS-485 Multi-Drop Configuration Example

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/SerialParameters.md

Sets up SerialParameters for an RS-485 multi-drop network, including enabling RS-485 mode, configuring TX enable, and setting transmission delays.

```java
SerialParameters params = new SerialParameters("COM1", 19200);
params.setEncoding("rtu");
params.setRs485Mode(true);
params.setRs485TxEnableActiveHigh(true);
params.setRs485DelayBeforeTxMicroseconds(100);
params.setRs485DelayAfterTxMicroseconds(100);

ModbusSerialMaster master = new ModbusSerialMaster(params);
```

--------------------------------

### Start Modbus Slave Listener

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/ModbusSlave.md

Starts the slave listener thread to accept client connections. Ensure the slave is configured before calling this method. Check getError() for startup issues.

```java
ModbusSlave slave = ModbusSlaveFactory.createTCPSlave(502, 5);
ProcessImage image = new SimpleProcessImage();
slave.addProcessImage(1, image);
slave.open();
System.out.println("Slave started on port " + slave.getPort());
```

--------------------------------

### Java ObservableRegister Event Handling

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/Register.md

Shows how to create ObservableRegisters and attach observers to react to value changes. Demonstrates triggering observers manually by setting new values and includes examples of comparing register values.

```java
ObservableRegister temperature = new ObservableRegister(20000);  // 20.00°C
ObservableRegister setpoint = new ObservableRegister(22000);     // 22.00°C

temperature.addObserver((obs, arg) -> {
    int temp = temperature.getValue();
    if (temp > setpoint.getValue()) {
        System.out.println("Temperature exceeds setpoint!");
    }
});

setpoint.addObserver((obs, arg) -> {
    System.out.println("Setpoint changed to: " + (setpoint.getValue() / 100.0) + "°C");
});

// Trigger observers
temperature.setValue(25000);  // 25.00°C - triggers temperature observer
setpoint.setValue(24000);     // 24.00°C - triggers setpoint observer
```

--------------------------------

### toShort

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/ProcessImage.md

Gets the register value as a signed 16-bit integer.

```APIDOC
## toShort()

### Description
Gets the register value as a signed 16-bit integer (-32768 to 32767).

### Returns
- **short** - signed value
```

--------------------------------

### Create and Close a Single TCP Slave using Factory

Source: https://github.com/steveohara/j2mod/wiki/How-to-create-a-Modbus-Slave

This example shows how to create a TCP slave and add a process image. It utilizes the ModbusSlaveFactory to close all managed slaves later, eliminating the need to hold a reference to individual slave objects.

```java
    ProcessImage image = makeMyProcessImage();

    ModbusSlave slave = ModbusSlaveFactory.createTCPSlave(502, 5);
    slave.addProcessImage(1, image);
    slave.open();
    .....
    // Closes all slaves (means we don't have to carry around a reference to the slave)
    ModbusSlaveFactory.close(); 
```

--------------------------------

### getOpenDelay() / setOpenDelay(int openDelay)

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/SerialParameters.md

Gets or sets the delay in milliseconds after opening the serial port before the first communication attempt.

```APIDOC
## getOpenDelay() / setOpenDelay(int openDelay)

### Description
Gets or sets the delay in milliseconds after opening the serial port before the first communication attempt.

### Method
- `getOpenDelay()`: Retrieves the current open delay in milliseconds.
- `setOpenDelay(int openDelay)`: Sets the open delay in milliseconds.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```java
params.setOpenDelay(500);  // Wait 500ms after opening
```

### Response
#### Success Response (200)
- `getOpenDelay()` returns an int representing the open delay in milliseconds.
- `setOpenDelay(int openDelay)` returns void.

#### Response Example
```java
// For getOpenDelay()
500
```
```

--------------------------------

### Set and Get Serial Port Name

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/SerialParameters.md

Sets or gets the serial port name. Platform-specific examples are provided for Windows, Linux, and macOS.

```java
public String getPortName()
public void setPortName(String name)
```

```java
SerialParameters params = new SerialParameters();
params.setPortName("COM1");
System.out.println("Port: " + params.getPortName());
```

--------------------------------

### getPortName() / setPortName(String name)

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/SerialParameters.md

Gets or sets the serial port name. This method allows you to specify the communication port, with platform-specific examples provided for Windows, Linux, and macOS.

```APIDOC
## getPortName() / setPortName(String name)

### Description
Gets or sets the serial port name. This method allows you to specify the communication port, with platform-specific examples provided for Windows, Linux, and macOS.

### Method
- `getPortName()`: Retrieves the current serial port name.
- `setPortName(String name)`: Sets the serial port name.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```java
SerialParameters params = new SerialParameters();
params.setPortName("COM1");
System.out.println("Port: " + params.getPortName());
```

### Response
#### Success Response (200)
- `getPortName()` returns a String representing the port name.
- `setPortName(String name)` returns void.

#### Response Example
```java
// For getPortName()
"COM1"
```
```

--------------------------------

### Set and Get Encoding

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/SerialParameters.md

Sets or gets the Modbus serial encoding mode. Supports 'ascii' and 'rtu' modes.

```java
public String getEncoding()
public void setEncoding(String enc)
```

```java
params.setEncoding("rtu");  // Use RTU encoding
System.out.println("Encoding: " + params.getEncoding());
```

--------------------------------

### Set and Get Output Flow Control

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/SerialParameters.md

Sets or gets the output flow control mode for serial communication.

```java
public int getFlowControlOut()
public void setFlowControlOut(int flowControlOut)
```

--------------------------------

### Set and Get Parity

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/SerialParameters.md

Sets or gets the parity mode for serial communication. Various parity values are supported.

```java
public int getParity()
public void setParity(int parity)
```

```java
import com.fazecast.jSerialComm.SerialPort;

params.setParity(SerialPort.PARITY_NONE);
```

--------------------------------

### Configure Observable Process Images

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/configuration.md

Demonstrates how to create observable process images and attach observers to specific registers and digital outputs. Observers are notified when the value or state of these elements changes, allowing for real-time updates or event handling.

```java
ProcessImage image = new SimpleProcessImage();

// Add observer to register
ObservableRegister reg = new ObservableRegister(0);
reg.addObserver((observable, arg) -> {
    System.out.println("Register changed: " + reg.getValue());
    // Update display, log event, etc.
});

// Add observer to coil
ObservableDigitalOut coil = new ObservableDigitalOut(false);
coil.addObserver((observable, arg) -> {
    System.out.println("Coil state: " + coil.isSet());
    // Trigger relay, alarm, etc.
});
```

--------------------------------

### Create a Single TCP Slave

Source: https://github.com/steveohara/j2mod/wiki/How-to-create-a-Modbus-Slave

This snippet demonstrates how to create a single TCP Modbus slave, add a process image for a specific unit ID, and open the slave to start listening. Ensure the port is not already in use.

```java
    // Create your register set
    ProcessImage image = makeMyProcessImage();

    // Create a slave to listen on port 502 and create a pool of 5 listener threads
    // This will create a new slave or return you the same slave already assigned to this port
    ModbusSlave slave = ModbusSlaveFactory.createTCPSlave(502, 5);

    // Add the register set to the slave for unit ID 1
    // Each slave can have multiple process images but they must have a unique Unit ID within the slave
    slave.addProcessImage(1, image);

    // Start the slave listening on the port - this will throw an error if the socket is already in use
    slave.open();
    .....
    // Close the slave - closes the socket and stops listening
    slave.close();
```

--------------------------------

### Set and Get Stop Bits

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/SerialParameters.md

Sets or gets the number of stop bits per character for serial communication.

```java
public int getStopbits()
public void setStopbits(int stopbits)
```

--------------------------------

### Initialize Slave with Data

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/ProcessImage.md

Initializes a SimpleProcessImage with holding registers and coils, then registers it with a Modbus slave. Ensure the ModbusSlaveFactory is available and the port is correctly specified.

```java
ProcessImage image = new SimpleProcessImage();

// Initialize holding registers (address 0-9 with values 0-900)
for (int i = 0; i < 10; i++) {
    image.getRegister(i).setValue(i * 100);
}

// Initialize coils (address 0-15 with alternating pattern)
for (int i = 0; i < 16; i++) {
    image.getDigitalOut(i).set(i % 2 == 0);
}

// Register with slave
ModbusSlave slave = ModbusSlaveFactory.createTCPSlave(502, 5);
slave.addProcessImage(1, image);
slave.open();
```

--------------------------------

### Set and Get Data Bits

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/SerialParameters.md

Sets or gets the number of data bits per character for serial communication.

```java
public int getDatabits()
public void setDatabits(int databits)
```

--------------------------------

### Create SerialParameters with Defaults

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/SerialParameters.md

Instantiate SerialParameters using default settings and then customize port name and baud rate.

```java
SerialParameters params = new SerialParameters();
params.setPortName("COM3");
params.setBaudRate(9600);
```

--------------------------------

### Get File by Number

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/ProcessImage.md

Retrieves a file record using its file number. This is an alternative to getting a file by its address.

```java
File getFileByNumber(int ref)
```

--------------------------------

### Creating a TCP Slave on a Different Port

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/errors.md

Example of creating a Modbus TCP slave instance configured to listen on a port other than the default (502). This is useful for resolving 'Address already in use' errors.

```java
// Try with different port
ModbusSlave slave = ModbusSlaveFactory.createTCPSlave(5020, 5);
```

--------------------------------

### Configuring Serial Port Parameters

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/errors.md

Shows how to set up `SerialParameters` for a Modbus serial connection, including specifying the port name and baud rate. An `OpenDelay` is added to allow the OS time to recognize the port.

```java
// List available ports (platform-dependent)
// Windows: enumerate COM1, COM2, etc.
// Linux: check /dev/ttyS*, /dev/ttyUSB*
// macOS: check /dev/tty.*, /dev/cu.*

SerialParameters params = new SerialParameters("COM1", 19200);
params.setOpenDelay(500);  // Add delay after opening
```

--------------------------------

### Set and Get Open Delay

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/SerialParameters.md

Sets or gets the delay in milliseconds after opening the serial port before the first communication attempt.

```java
public int getOpenDelay()
public void setOpenDelay(int openDelay)
```

```java
params.setOpenDelay(500);  // Wait 500ms after opening
```

--------------------------------

### Set and Get Baud Rate

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/SerialParameters.md

Sets or gets the baud rate for serial communication. Common baud rates are listed.

```java
public int getBaudRate()
public void setBaudRate(int rate)
```

```java
params.setBaudRate(9600);
System.out.println("Baud rate: " + params.getBaudRate() + " bps");
```

--------------------------------

### createTCPSlave(InetAddress address, int port, int poolSize, boolean useRtuOverTcp, int maxIdleSeconds)

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/ModbusSlave.md

Creates a TCP slave with advanced options including bind address and idle timeout.

```APIDOC
## createTCPSlave(InetAddress address, int port, int poolSize, boolean useRtuOverTcp, int maxIdleSeconds)

### Description
Creates a TCP slave with advanced options including bind address and idle timeout.

### Method
static ModbusSlave

### Parameters
#### Path Parameters
- **address** (InetAddress) - Required - IP address to bind to (or null for all interfaces)
- **port** (int) - Required - TCP port to listen on
- **poolSize** (int) - Required - Thread pool size
- **useRtuOverTcp** (boolean) - Required - Use RTU protocol encapsulation (default: false)
- **maxIdleSeconds** (int) - Required - Maximum idle time before closing connection (0 = no timeout)

### Request Example
```java
InetAddress address = InetAddress.getByName("192.168.1.1");
ModbusSlave slave = ModbusSlaveFactory.createTCPSlave(address, 502, 5, false, 300);
```

### Response
#### Success Response
- **ModbusSlave** - TCP slave instance

#### Throws
- **ModbusException** - if port is already in use
```

--------------------------------

### Set and Get Echo Mode

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/SerialParameters.md

Sets or gets the echo mode for serial communication. This is rarely used and typically set to false.

```java
public boolean isEcho()
public void setEcho(boolean newEcho)
```

--------------------------------

### Set and Get Input Flow Control

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/SerialParameters.md

Sets or gets the input flow control mode for serial communication. Options include disabled, CTS, RTS, and XON/XOFF.

```java
public int getFlowControlIn()
public void setFlowControlIn(int flowControl)
```

--------------------------------

### SerialParameters(String portName, int baudRate, int flowControlIn, int flowControlOut, int databits, int stopbits, int parity, boolean echo) Constructor

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/SerialParameters.md

Creates a serial parameters object with all standard settings provided by the user. This constructor allows for explicit configuration of port name, baud rate, flow control, data bits, stop bits, parity, and echo mode.

```APIDOC
## SerialParameters(String portName, int baudRate, int flowControlIn, int flowControlOut, int databits, int stopbits, int parity, boolean echo)

### Description
Creates a serial parameters object with all standard settings.

### Method
Constructor

### Parameters
#### Path Parameters
- **portName** (String) - Yes - Serial port name (e.g., "COM1", "/dev/ttyS0")
- **baudRate** (int) - Yes - Baud rate (300, 600, 1200, 2400, 4800, 9600, 19200, 38400, 57600, 115200, etc.)
- **flowControlIn** (int) - Yes - Input flow control (jSerialComm.SerialPort.FLOW_CONTROL_*)
- **flowControlOut** (int) - Yes - Output flow control (jSerialComm.SerialPort.FLOW_CONTROL_*)
- **databits** (int) - Yes - Data bits (5, 6, 7, 8)
- **stopbits** (int) - Yes - Stop bits (1, 2)
- **parity** (int) - Yes - Parity (jSerialComm.SerialPort.PARITY_*)
- **echo** (boolean) - Yes - Echo mode (usually false)

### Request Example
```java
import com.fazecast.jSerialComm.SerialPort;

SerialParameters params = new SerialParameters(
    "COM1", 19200,
    SerialPort.FLOW_CONTROL_DISABLED,
    SerialPort.FLOW_CONTROL_DISABLED,
    8, 1,
    SerialPort.PARITY_NONE,
    false
);
```

### Response
#### Success Response
- **SerialParameters** (object) - A new SerialParameters object configured with the provided settings.
```

--------------------------------

### Create ModbusTCPMaster with Advanced Options

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/ModbusTCPMaster.md

Instantiate ModbusTCPMaster with all options, including RTU over TCP and proxy support. Configure connection parameters and specify proxy settings if needed.

```java
Proxy proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress("proxy.company.com", 8080));
ModbusTCPMaster master = new ModbusTCPMaster("192.168.1.100", 502, 3000, false, false, proxy);
```

--------------------------------

### toBytes

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/ProcessImage.md

Gets the register value as a 2-byte array.

```APIDOC
## toBytes()

### Description
Gets the register value as a 2-byte array.

### Returns
- **byte[]** - [MSB, LSB]

### Example
```java
Register reg = new SimpleRegister(0x1234);
byte[] bytes = reg.toBytes();
System.out.printf("Bytes: 0x%02X 0x%02X\n", bytes[0], bytes[1]);  // 0x12 0x34
```
```

--------------------------------

### Create SimpleDigitalOut

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/ProcessImage.md

Demonstrates the creation and basic operations of SimpleDigitalOut, representing a coil (digital output). It can be initialized with a state and its state can be set and checked.

```java
public SimpleDigitalOut()
public SimpleDigitalOut(boolean state)
```

```java
DigitalOut coil = new SimpleDigitalOut(true);
coil.set(false);
if (coil.isSet()) {
    System.out.println("Coil is ON");
}
```

--------------------------------

### Java Process Image Initialization

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/Register.md

Illustrates how to initialize holding registers within a ProcessImage by setting values in a loop. Input registers are also iterated, though their initialization logic is typically handled differently.

```java
ProcessImage image = new SimpleProcessImage();

// Initialize holding registers with values
for (int i = 0; i < 100; i++) {
    image.getRegister(i).setValue(i * 10);
}

// Initialize input registers (read-only for slave)
for (int i = 0; i < 50; i++) {
    // Note: Input registers in process image are typically SimpleInputRegister
    // but accessed through ProcessImage interface
}
```

--------------------------------

### getRs485EnableTermination / setRs485EnableTermination

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/SerialParameters.md

Gets or sets the control for the RS-485 termination resistor.

```APIDOC
## setRs485EnableTermination(enable)

### Description
Gets or sets termination resistor control for RS-485.

### Method
`void setRs485EnableTermination(boolean enable)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Response
None

### Error Handling
None
```

--------------------------------

### ObservableRegister Constructors and Methods

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/types.md

Provides constructors and methods for `ObservableRegister`, a register with observer/listener support.

```APIDOC
## ObservableRegister Constructors and Methods

### Description
Provides constructors and methods for the `ObservableRegister` class, a register that supports observer pattern for state changes.

### Constructors
- `ObservableRegister()`
- `ObservableRegister(int value)`
- `ObservableRegister(byte[] bytes)`

### Methods
- `void addObserver(Observer o)`: Adds an observer to the register.
- `void removeObserver(Observer o)`: Removes an observer from the register.
```

--------------------------------

### getValue / toUnsignedShort

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/ProcessImage.md

Gets the register value as an unsigned 16-bit integer.

```APIDOC
## getValue()
## toUnsignedShort()

### Description
Gets the register value as an unsigned 16-bit integer (0-65535).

### Returns
- **int** - value from 0 to 65535

### Example
```java
Register reg = new SimpleRegister(0xFFFF);
System.out.println("Value: " + reg.getValue());  // 65535
```
```

--------------------------------

### Get File Count

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/ProcessImage.md

Returns the total number of files managed by the ProcessImage.

```java
int getFileCount()
```

--------------------------------

### connect()

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/ModbusSerialMaster.md

Opens the serial port and establishes communication with the Modbus slave. This method must be called before any read or write operations can be performed.

```APIDOC
## connect()

### Description
Opens the serial port and establishes communication with the Modbus slave. Must be called before any read/write operations.

### Method
`public synchronized void connect() throws Exception`

### Throws
- `Exception` if the serial port cannot be opened or configured
- Common issues: port in use, invalid parameters, permissions denied

### Example
```java
SerialParameters params = new SerialParameters("COM1", 19200);
ModbusSerialMaster master = new ModbusSerialMaster(params);
try {
    master.connect();
    // perform operations
} catch (Exception e) {
    System.err.println("Failed to open serial port: " + e.getMessage());
}
```
```

--------------------------------

### Get BitVector Size

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/BitVector.md

Return the total number of bits currently managed by the BitVector.

```java
public int size()
```

```java
BitVector bits = new BitVector(10);
System.out.println("Vector size: " + bits.size());  // 10
```

--------------------------------

### Create Modbus TCP, UDP, and Serial Masters

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/README.md

Demonstrates how to instantiate Modbus masters for TCP, UDP, and serial communication. TCP is the most common. Serial requires specific parameters.

```java
// TCP: Most common
ModbusTCPMaster tcp = new ModbusTCPMaster("192.168.1.100");

// UDP: Simpler, less reliable
ModbusUDPMaster udp = new ModbusUDPMaster("192.168.1.100");

// Serial: For RS-232/RS-485 devices
SerialParameters params = new SerialParameters("COM1", 19200);
ModbusSerialMaster serial = new ModbusSerialMaster(params);
```

--------------------------------

### Get FIFO Queue Count

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/ProcessImage.md

Returns the total number of FIFO queues managed by the ProcessImage.

```java
int getFIFOCount()
```

--------------------------------

### Create ModbusTCPMaster with Default Settings

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/ModbusTCPMaster.md

Instantiate ModbusTCPMaster with a specified IP address or hostname. Uses default port (502), timeout (3000ms), and ASCII encoding. Connect and disconnect explicitly.

```java
ModbusTCPMaster master = new ModbusTCPMaster("192.168.1.100");
master.connect();
try {
    int[] registers = master.readMultipleRegisters(0, 10);
} finally {
    master.disconnect();
}
```

--------------------------------

### Get InputRegister Value as Unsigned Short

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/Register.md

Retrieves the value of an InputRegister as an unsigned 16-bit integer.

```java
int unsignedValue = register.toUnsignedShort();
System.out.println("Unsigned: " + unsignedValue);
```

--------------------------------

### Create ModbusUDPMaster with Default Settings

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/ModbusUDPMaster.md

Instantiate a ModbusUDPMaster with the slave device's IP address. Uses default port (502) and timeout (3000ms). Connect to the slave after instantiation.

```java
ModbusUDPMaster master = new ModbusUDPMaster("192.168.1.100");
master.connect();
```

--------------------------------

### Get Modbus Slave Thread Name

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/ModbusSlave.md

Retrieves the name of the thread used by the slave listener.

```java
slave.getThreadName();
```

--------------------------------

### createUDPSlave(int port)

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/ModbusSlave.md

Creates a UDP slave listening on the specified port.

```APIDOC
## createUDPSlave(int port)

### Description
Creates a UDP slave listening on the specified port.

### Method
static ModbusSlave

### Parameters
#### Path Parameters
- **port** (int) - Required - UDP port to listen on

### Request Example
```java
ModbusSlave slave = ModbusSlaveFactory.createUDPSlave(502);
```

### Response
#### Success Response
- **ModbusSlave** - UDP slave instance

#### Throws
- **ModbusException** - if port is already in use
```

--------------------------------

### Get Modbus Serial Parameters

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/ModbusSlave.md

Retrieves the serial communication parameters for serial Modbus slaves.

```java
slave.getSerialParams();
```

--------------------------------

### SimpleProcessImage Constructors

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/types.md

Provides constructors for `SimpleProcessImage`, an in-memory implementation of the Modbus process image.

```APIDOC
## SimpleProcessImage Constructors

### Description
Constructors for the `SimpleProcessImage` class, an in-memory representation of the Modbus process image.

### Constructors
- `SimpleProcessImage()`
- `SimpleProcessImage(int unit)`
```

--------------------------------

### Get Modbus Slave Port

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/ModbusSlave.md

Retrieves the port number for IP-based Modbus slaves (TCP/UDP).

```java
slave.getPort();
```

--------------------------------

### createTCPSlave(int port, int poolSize)

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/ModbusSlave.md

Creates a TCP slave listening on the specified port with a given thread pool size.

```APIDOC
## createTCPSlave(int port, int poolSize)

### Description
Creates a TCP slave listening on the specified port.

### Method
static ModbusSlave

### Parameters
#### Path Parameters
- **port** (int) - Required - TCP port to listen on (1-65535)
- **poolSize** (int) - Required - Thread pool size for handling connections

### Request Example
```java
ModbusSlave slave = ModbusSlaveFactory.createTCPSlave(502, 5);
ProcessImage image = new SimpleProcessImage();
slave.addProcessImage(1, image);
slave.open();
```

### Response
#### Success Response
- **ModbusSlave** - TCP slave instance

#### Throws
- **ModbusException** - if port is already in use or invalid
```

--------------------------------

### getFlowControlOut() / setFlowControlOut(int flowControlOut)

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/SerialParameters.md

Gets or sets the output flow control setting for serial communication.

```APIDOC
## getFlowControlOut() / setFlowControlOut(int flowControlOut)

### Description
Gets or sets the output flow control setting for serial communication.

### Method
- `getFlowControlOut()`: Retrieves the current output flow control setting.
- `setFlowControlOut(int flowControlOut)`: Sets the output flow control setting.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```java
params.setFlowControlOut(SerialPort.FLOW_CONTROL_DISABLED);
```

### Response
#### Success Response (200)
- `getFlowControlOut()` returns an int representing the output flow control setting.
- `setFlowControlOut(int flowControlOut)` returns void.

#### Response Example
```java
// For getFlowControlOut()
0 // Represents FLOW_CONTROL_DISABLED
```
```

--------------------------------

### connect()

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/ModbusUDPMaster.md

Opens the UDP socket for communication with the Modbus UDP slave. Must be called before any read/write operations.

```APIDOC
## connect()

### Description
Opens the UDP socket for communication with the Modbus UDP slave. Must be called before any read/write operations.

### Method
`public synchronized void connect() throws Exception`

### Throws
- `Exception` if the connection cannot be established
- `SocketException` if the UDP socket cannot be created

### Example
```java
ModbusUDPMaster master = new ModbusUDPMaster("192.168.1.100");
try {
    master.connect();
    // perform operations
} catch (Exception e) {
    System.err.println("Failed to connect: " + e.getMessage());
}
```
```

--------------------------------

### SimpleProcessImage Constructor

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/ProcessImage.md

Creates a new instance of SimpleProcessImage, optionally with a specified unit ID.

```APIDOC
## SimpleProcessImage()
## SimpleProcessImage(int unit)

### Description
Creates a process image with default capacity.

### Parameters
#### Path Parameters
- **unit** (int) - Optional - Unit ID (for reference)

### Example
```java
ProcessImage image = new SimpleProcessImage();
ProcessImage unitImage = new SimpleProcessImage(1);
```
```

--------------------------------

### Get File by Reference

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/ProcessImage.md

Retrieves a file record using its address. This method is part of the ProcessImage API.

```java
File getFile(int ref)
```

--------------------------------

### Basic ModbusTCPMaster Constructor

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/configuration.md

Instantiate a ModbusTCPMaster with a required address. Other options like port, timeout, and connection mode can be configured separately.

```java
ModbusTCPMaster master = new ModbusTCPMaster(String address);
```

--------------------------------

### Get FIFO Queue by Reference

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/ProcessImage.md

Retrieves a FIFO queue using its address. This method is part of the ProcessImage API.

```java
FIFO getFIFO(int ref)
```

--------------------------------

### ObservableDigitalOut Constructors and Methods

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/types.md

Provides constructors and methods for `ObservableDigitalOut`, a coil with observer/listener support.

```APIDOC
## ObservableDigitalOut Constructors and Methods

### Description
Provides constructors and methods for the `ObservableDigitalOut` class, a coil that supports observer pattern for state changes.

### Constructors
- `ObservableDigitalOut()`
- `ObservableDigitalOut(boolean state)`

### Methods
- `void addObserver(Observer o)`: Adds an observer to the coil.
- `void removeObserver(Observer o)`: Removes an observer from the coil.
```

--------------------------------

### connect()

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/ModbusTCPMaster.md

Establishes a connection to the Modbus TCP slave. This method must be called before any read or write operations can be performed.

```APIDOC
## connect()

### Description
Establishes connection to the Modbus TCP slave. Must be called before any read/write operations.

### Method
`public synchronized void connect() throws Exception`

### Throws
- `Exception` if the connection cannot be established
- `SocketException` if the port is already in use or address is invalid

### Example
```java
ModbusTCPMaster master = new ModbusTCPMaster("192.168.1.100");
try {
    master.connect();
    // perform operations
} catch (Exception e) {
    System.err.println("Failed to connect: " + e.getMessage());
}
```
```

--------------------------------

### Getting the Total Number of Input Registers

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/ProcessImage.md

Returns the total count of input registers available in the process image.

```java
int getInputRegisterCount()
```

--------------------------------

### Getting a Range of Input Registers

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/ProcessImage.md

Retrieves a specified range of input registers from the process image. These registers are read-only.

```java
InputRegister[] getInputRegisterRange(int offset, int count)
```

--------------------------------

### Create SimpleDigitalIn

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/ProcessImage.md

Shows the constructors for SimpleDigitalIn, representing a discrete input (digital input). It can be initialized with a state and its state can be checked.

```java
public SimpleDigitalIn()
public SimpleDigitalIn(boolean state)
```

```java
DigitalIn input = new SimpleDigitalIn(true);
if (input.isSet()) {
    System.out.println("Input is ON");
}
```

--------------------------------

### Getting the Total Number of Holding Registers

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/ProcessImage.md

Returns the total count of holding registers available in the process image.

```java
int getRegisterCount()
```

--------------------------------

### Full ModbusTCPMaster Constructor

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/configuration.md

Instantiate a ModbusTCPMaster with all available options including address, port, timeout, reconnect behavior, protocol, and an optional proxy.

```java
ModbusTCPMaster master = new ModbusTCPMaster(
    String address,      // IP or hostname
    int port,            // port number
    int timeout,         // milliseconds
    boolean reconnect,   // per-transaction or persistent
    boolean useRtuOverTcp, // RTU or TCP protocol
    Proxy proxy          // HTTP proxy (optional)
);
```

--------------------------------

### Configuration Methods

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/ModbusSerialMaster.md

Methods for configuring the Modbus serial master's behavior.

```APIDOC
## setTimeout

### Description
Sets the timeout for Modbus requests in milliseconds.

### Method
`setTimeout(int timeout): void`

### Parameters
- **timeout** (int) - The timeout value in milliseconds.

## setRetries

### Description
Sets the number of retries for Modbus requests.

### Method
`setRetries(int retries): void`

### Parameters
- **retries** (int) - The number of retries.

## setCheckingValidity

### Description
Enables or disables the validity check for Modbus responses.

### Method
`setCheckingValidity(boolean b): void`

### Parameters
- **b** (boolean) - True to enable validity checking, false to disable.
```

--------------------------------

### Get InputRegister Value as Bytes

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/Register.md

Retrieves the value of an InputRegister as a 2-byte array in Modbus byte order (big-endian).

```java
InputRegister reg = regs[0];
byte[] bytes = reg.toBytes();
System.out.printf("Bytes: 0x%02X 0x%02X\n", bytes[0], bytes[1]);

// Example: value 0x1234 returns [0x12, 0x34]
```

--------------------------------

### Create and Initialize BitVector

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/BitVector.md

Create a new BitVector with a specified size. All bits are initialized to false. Recommended size is between 1 and 2000.

```java
public BitVector(int size)
```

```java
BitVector coils = new BitVector(10);
for (int i = 0; i < coils.size(); i++) {
    System.out.println("Bit " + i + ": " + coils.getBit(i));
}
```

--------------------------------

### writeMultipleRegisters

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/ModbusTCPMaster.md

Writes multiple Modbus registers starting from the specified address to the slave device. This operation is synchronized and thread-safe.

```APIDOC
## writeMultipleRegisters(int ref, Register[] registers)

### Description
Writes multiple register values to the slave.

### Method
writeMultipleRegisters

### Parameters
#### Path Parameters
- **ref** (int) - Required - Starting register address (0-based)
- **registers** (Register[]) - Required - Register values to write (max 123)

### Response
#### Success Response
- **return value** (int) - the number of registers written

### Throws
- **ModbusException** - if I/O error, slave exception, or transaction error occurs

### Example
```java
Register[] regs = new Register[3];
regs[0] = new SimpleRegister(100);
regs[1] = new SimpleRegister(200);
regs[2] = new SimpleRegister(300);
int count = master.writeMultipleRegisters(20, regs);
```
```

--------------------------------

### Handle IOException for Serial Operations

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/errors.md

Catch and report a general IOException for failures during serial Modbus communication setup.

```java
try {
    SerialParameters params = new SerialParameters("COM1", 19200);
    ModbusSerialMaster master = new ModbusSerialMaster(params);
    master.connect();
} catch (IOException e) {
    System.err.println("Serial port error: " + e.getMessage());
}
```

--------------------------------

### SimpleInputRegister Constructors

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/ProcessImage.md

Creates a new instance of SimpleInputRegister, initializing with a default value, an integer, or a byte array.

```APIDOC
## SimpleInputRegister()
## SimpleInputRegister(int value)
## SimpleInputRegister(byte[] bytes)

### Description
Read-only register implementation.
```

--------------------------------

### SerialParameters with RS-485 Support Constructor

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/SerialParameters.md

Creates a serial parameters object with RS-485 specific settings in addition to standard serial parameters. This constructor is for advanced configurations requiring RS-485 mode, TX enable polarity, and transmission delay settings.

```APIDOC
## SerialParameters(String portName, int baudRate, int flowControlIn, int flowControlOut, int databits, int stopbits, int parity, boolean echo, boolean rs485Mode, boolean rs485TxEnableActiveHigh, int rs485DelayBeforeTxMicroseconds, int rs485DelayAfterTxMicroseconds)

### Description
Creates a serial parameters object with RS-485 specific settings.

### Method
Constructor

### Parameters
#### Path Parameters
- **portName** (String) - Yes - Serial port name
- **baudRate** (int) - Yes - Baud rate
- **flowControlIn** (int) - Yes - Input flow control
- **flowControlOut** (int) - Yes - Output flow control
- **databits** (int) - Yes - Data bits
- **stopbits** (int) - Yes - Stop bits
- **parity** (int) - Yes - Parity
- **echo** (boolean) - Yes - Echo mode
- **rs485Mode** (boolean) - Yes - Enable RS-485 mode
- **rs485TxEnableActiveHigh** (boolean) - Yes - TX enable signal active high (true) or low (false)
- **rs485DelayBeforeTxMicroseconds** (int) - Yes - Microseconds delay before transmission
- **rs485DelayAfterTxMicroseconds** (int) - Yes - Microseconds delay after transmission

### Request Example
```java
SerialParameters params = new SerialParameters(
    "COM1", 19200,
    SerialPort.FLOW_CONTROL_DISABLED,
    SerialPort.FLOW_CONTROL_DISABLED,
    8, 1,
    SerialPort.PARITY_NONE,
    false,
    true,        // Enable RS-485
    true,        // TX enable active high
    10,          // 10 microseconds before TX
    10           // 10 microseconds after TX
);
```

### Response
#### Success Response
- **SerialParameters** (object) - A new SerialParameters object configured with RS-485 specific settings.
```

--------------------------------

### getRs485DelayAfterTxMicroseconds / setRs485DelayAfterTxMicroseconds

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/SerialParameters.md

Gets or sets the delay in microseconds after RS-485 transmission completes. Use `setRs485DelayAfterTxMicroseconds(microseconds)` to set the delay.

```APIDOC
## setRs485DelayAfterTxMicroseconds(microseconds)

### Description
Gets or sets the delay in microseconds after transmission completes.

### Method
`void setRs485DelayAfterTxMicroseconds(int microseconds)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```java
params.setRs485DelayAfterTxMicroseconds(10);
```

### Response
None

### Error Handling
None
```

--------------------------------

### getRs485DelayBeforeTxMicroseconds / setRs485DelayBeforeTxMicroseconds

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/SerialParameters.md

Gets or sets the delay in microseconds before RS-485 transmission begins. Use `setRs485DelayBeforeTxMicroseconds(microseconds)` to set the delay.

```APIDOC
## setRs485DelayBeforeTxMicroseconds(microseconds)

### Description
Gets or sets the delay in microseconds before transmission begins.

### Method
`void setRs485DelayBeforeTxMicroseconds(int microseconds)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```java
params.setRs485DelayBeforeTxMicroseconds(10);
```

### Response
None

### Error Handling
None
```

--------------------------------

### ModbusTCPMaster Constructors

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/ModbusTCPMaster.md

Provides details on the various constructors available for initializing a ModbusTCPMaster instance, allowing configuration of connection parameters such as address, port, timeout, and reconnection behavior.

```APIDOC
## ModbusTCPMaster(String addr)

### Description
Creates a new master instance with default settings (port 502, timeout 3000ms, ASCII encoding).

### Parameters
#### Path Parameters
- **addr** (String) - Required - IP address or hostname of the Modbus slave

### Throws
- `RuntimeException` if hostname cannot be resolved

### Example
```java
ModbusTCPMaster master = new ModbusTCPMaster("192.168.1.100");
master.connect();
try {
    int[] registers = master.readMultipleRegisters(0, 10);
} finally {
    master.disconnect();
}
```
```

```APIDOC
## ModbusTCPMaster(String addr, int port)

### Description
Creates a new master instance with specified port and default timeout.

### Parameters
#### Path Parameters
- **addr** (String) - Required - IP address or hostname of the Modbus slave
- **port** (int) - Required - TCP port number the slave is listening on

### Throws
- `RuntimeException` if hostname cannot be resolved

### Example
```java
ModbusTCPMaster master = new ModbusTCPMaster("192.168.1.100", 5020);
```
```

```APIDOC
## ModbusTCPMaster(String addr, int port, int timeout, boolean reconnect)

### Description
Creates a new master instance with full control over connection parameters.

### Parameters
#### Path Parameters
- **addr** (String) - Required - IP address or hostname of the Modbus slave
- **port** (int) - Required - TCP port number the slave is listening on
- **timeout** (int) - Required - Socket timeout in milliseconds
- **reconnect** (boolean) - Required - If true, establishes a new connection for each transaction; if false, maintains persistent connection

### Throws
- `RuntimeException` if hostname cannot be resolved

### Example
```java
ModbusTCPMaster master = new ModbusTCPMaster("192.168.1.100", 502, 5000, false);
```
```

```APIDOC
## ModbusTCPMaster(String addr, int port, int timeout, boolean reconnect, boolean useRtuOverTcp, Proxy proxy)

### Description
Creates a new master instance with all available options including RTU over TCP and proxy support.

### Parameters
#### Path Parameters
- **addr** (String) - Required - IP address or hostname of the Modbus slave
- **port** (int) - Required - TCP port number the slave is listening on
- **timeout** (int) - Required - Socket timeout in milliseconds
- **reconnect** (boolean) - Required - If true, creates new connection per transaction
- **useRtuOverTcp** (boolean) - Required - If true, uses RTU protocol encapsulation over TCP instead of standard TCP
- **proxy** (Proxy) - Optional - Java Proxy object for routing through HTTP proxy

### Throws
- `RuntimeException` if hostname cannot be resolved

### Example
```java
Proxy proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress("proxy.company.com", 8080));
ModbusTCPMaster master = new ModbusTCPMaster("192.168.1.100", 502, 3000, false, false, proxy);
```
```

--------------------------------

### getRs485RxDuringTx / setRs485RxDuringTx

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/SerialParameters.md

Gets or sets whether to receive data while transmitting, useful for echo cancellation testing in RS-485 mode.

```APIDOC
## setRs485RxDuringTx(enable)

### Description
Gets or sets whether to receive while transmitting (for echo cancellation testing).

### Method
`void setRs485RxDuringTx(boolean enable)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Response
None

### Error Handling
None
```

--------------------------------

### Create SerialParameters with RS-485 Support

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/SerialParameters.md

Initialize SerialParameters with RS-485 specific settings, including RS-485 mode, TX enable polarity, and transmission delays.

```java
SerialParameters params = new SerialParameters(
    "COM1", 19200,
    SerialPort.FLOW_CONTROL_DISABLED,
    SerialPort.FLOW_CONTROL_DISABLED,
    8, 1,
    SerialPort.PARITY_NONE,
    false,
    true,        // Enable RS-485
    true,        // TX enable active high
    10,          // 10 microseconds before TX
    10           // 10 microseconds after TX
);
```

--------------------------------

### Create Modbus TCP, UDP, and Serial Slaves

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/README.md

Shows how to create Modbus slave instances for TCP, UDP, and serial communication. TCP requires a port and queue size, UDP requires a port, and serial requires serial parameters.

```java
// TCP
ModbusSlave tcp = ModbusSlaveFactory.createTCPSlave(502, 5);

// UDP
ModbusSlave udp = ModbusSlaveFactory.createUDPSlave(502);

// Serial
ModbusSlave serial = ModbusSlaveFactory.createSerialSlave(params);
```

--------------------------------

### getEncoding() / setEncoding(String enc)

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/SerialParameters.md

Gets or sets the Modbus serial encoding mode. Supported modes are 'ascii' and 'rtu'.

```APIDOC
## getEncoding() / setEncoding(String enc)

### Description
Gets or sets the Modbus serial encoding mode. Supported modes are 'ascii' and 'rtu'.

### Method
- `getEncoding()`: Retrieves the current encoding mode.
- `setEncoding(String enc)`: Sets the encoding mode.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```java
params.setEncoding("rtu");  // Use RTU encoding
System.out.println("Encoding: " + params.getEncoding());
```

### Response
#### Success Response (200)
- `getEncoding()` returns a String representing the encoding mode.
- `setEncoding(String enc)` returns void.

#### Response Example
```java
// For getEncoding()
"rtu"
```
```

--------------------------------

### Get FIFO Queue by Address (Alternative)

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/api-reference/ProcessImage.md

Retrieves a FIFO queue using its address, providing an alternative method to getFIFO.

```java
FIFO getFIFOByAddress(int ref)
```

--------------------------------

### SimpleProcessImage Constructors

Source: https://github.com/steveohara/j2mod/blob/master/_autodocs/types.md

Initializes an in-memory process image. Can be created with a default unit ID or a specified unit ID.

```java
SimpleProcessImage()

```

```java
SimpleProcessImage(int unit)

```
Tokens:
Raw