# atMb 0.8 API reference

Generated from `library/atMb-OnlineChange.export`. Declarations below are the current source. Use USER-GUIDE.md for lifecycle, units and examples. Internal fields remain exposed where required by existing IEC inheritance; do not overwrite engine state from application code.

## atMbCall_cext

Fixed external C entry point. Preserve parameter order/types and External implementation setting. Use FBs for application logic.

```iecst
FUNCTION atMbCall_cext : UDINT
VAR_INPUT
    
    command : UDINT;
    
    handle : UDINT;
    
    ipAddress : DWORD;
    
    port : UINT;
    
    unitId : BYTE;
    
    functionCode : BYTE;
    
    startAddress : UINT;
    
    quantity : UINT;
    
    pData : POINTER TO WORD;
    
    dataCapacity : UDINT;
    
    pStatus : POINTER TO UDINT;
    
    statusCapacity : UDINT;
    
    nowMs : ULINT;
    
    connectTimeoutMs : UDINT;
    
    responseTimeoutMs : UDINT;
    
    retryDelayMs : UDINT;
END_VAR
```

## ModbusMaster.ClientStatus

Retained legacy enum; clients now monitor a STRING through toString.

```iecst
{attribute 'qualified_only'}
{attribute 'strict'}
TYPE ClientStatus :
(
	noneOk := 0,
	someOk := 1,
	allOk := 2
);
END_TYPE
```

## ModbusMaster.Error

IEC result classification. TCP socket names also classify RTU OS failures. See out_errorCode for exact C result.

```iecst
{attribute 'qualified_only'}
TYPE Error : (
 OK := 0, RequestParameterError := 1, TcpSocketError := 4,
 TcpConnectTimeout := 5, ReplyTimeout := 6, InvalidReply := 8,
 RequestException := 9, RequestCancelled := 10, InternalError := 255
);
END_TYPE
```

## ModbusMaster.ExceptionCodes

Standard Modbus exception values and local TIMEOUT=-1. Only true timeout results set timeoutCnt in this version.

```iecst
{attribute 'qualified_only'}
TYPE ExceptionCodes :
(
    
    TIMEOUT := -1, 

    
    RESPONSE_SUCCESS := 16#00, 

    ILLEGAL_FUNCTION := 16#01, 
    ILLEGAL_DATA_ADDRESS := 16#02, 
    ILLEGAL_DATA_VALUE := 16#03, 
    SLAVE_DEVICE_FAILURE := 16#04, 

    ACKNOWLEDGE := 16#05, 
    SLAVE_DEVICE_BUSY := 16#06, 

    MEMORY_PARITY_ERROR := 16#08, 

    GATEWAY_PATH_UNAVAILABLE := 16#0A, 
    GATEWAY_TARGET_DEVICE_FAILED_TO_RESPOND := 16#0B 
);
END_TYPE
```

## ModbusMaster.ClientBase

Shared abstract client scheduler and registry. Call concrete client every scan; IEC task handles transaction progress. Exposes aggregated stats and toString.

```iecst
{attribute 'monitoring_display' := 'toString'}
{attribute 'no_assign'}
FUNCTION_BLOCK ABSTRACT ClientBase
VAR_INPUT
	{attribute 'symbol' := 'none'}
    
   	in_timeout: TIME := T#0MS; 
	{attribute 'symbol' := 'none'}
    
	in_resetStats: BOOL; 
END_VAR
VAR_OUTPUT
    {attribute 'symbol' := 'none'}
    
	msgLastSecondCnt: UDINT; 
    {attribute 'symbol' := 'none'}
    
	msgLastSecondTime: UDINT; 
    {attribute 'symbol' := 'none'}
    
	numMsgSent: UDINT;
    {attribute 'symbol' := 'none'}
    
	numMsgReply: UDINT;
    {attribute 'symbol' := 'none'}
    
	allRequestsOnline: BOOL; 
    
	reqStats: ARRAY[0..99] OF POINTER TO RequestStats; 
END_VAR
VAR
 dataRate : DINT;
 requests : ARRAY[0..99] OF POINTER TO RequestBase;
 requestCnt : UINT;
 allRequestsOffline : BOOL;
END_VAR
VAR
engineMode : BOOL;
engineHandle : UDINT;
engineIP : DWORD;
enginePort : UINT;
engineNowMicroseconds : SYSTIME;
engineNowMilliseconds : ULINT;
engineStatus : ARRAY[0..23] OF UDINT;
engineActiveIndex : DINT := -1;
engineSelected : POINTER TO RequestBase;
engineResultReady : BOOL;
engineFinishedIndex : DINT := -1;
engineWindowStartMilliseconds : ULINT;
engineWasConnected : BOOL;
engineEnable : BOOL := TRUE;
engineConnectTimeoutMilliseconds : UDINT := 2000;
engineRetryDelayMilliseconds : UDINT := 100;
engineHoldUncertainWrites : BOOL := FALSE;
END_VAR
VAR_INPUT
{attribute 'symbol' := 'none'}
engineIO : ARRAY[0..1999] OF WORD;
{attribute 'symbol' := 'none'}
engineActiveRequest : POINTER TO RequestBase;
{attribute 'symbol' := 'none'}
engineArgUnit : BYTE;
{attribute 'symbol' := 'none'}
engineArgFunction : BYTE;
{attribute 'symbol' := 'none'}
engineArgAddress : UINT;
{attribute 'symbol' := 'none'}
engineArgQuantity : UINT;
{attribute 'symbol' := 'none'}
engineArgTimeout : UDINT := 1000;
{attribute 'symbol' := 'none'}
engineSent : UDINT;
{attribute 'symbol' := 'none'}
engineReplied : UDINT;
{attribute 'symbol' := 'none'}
engineWindowCount : UDINT;
{attribute 'symbol' := 'none'}
engineWindowTime : UDINT;
END_VAR

VAR_OUTPUT
    
out_connected : BOOL;
    
out_connectionState : UDINT;
    
out_lastErrorCode : UDINT;
    
out_socketError : UDINT;
    
out_reconnectCount : UDINT;
    
out_registrationFull : BOOL;
END_VAR

VAR CONSTANT
 CMD_OPEN : UDINT := 1;
 CMD_CLOSE : UDINT := 2;
 CMD_ENABLE : UDINT := 3;
 CMD_TICK : UDINT := 5;
 CMD_SUBMIT : UDINT := 6;
 CMD_COPY_READ : UDINT := 7;
 CMD_CONFIGURE : UDINT := 9;
 CMD_ACKNOWLEDGE : UDINT := 10;
 CMD_REQUEST_TIMEOUT : UDINT := 11;
 STATE_DISABLED : UDINT := 0;
 STATE_READY : UDINT := 3;
 STATE_RECEIVING : UDINT := 5;
 ERROR_INVALID_HANDLE : UDINT := 256;
 ERROR_CANCELLED : UDINT := 10;
 STATUS_HANDLE : UDINT := 0;
 STATUS_STATE : UDINT := 1;
 STATUS_DONE : UDINT := 3;
 STATUS_ERROR : UDINT := 4;
 STATUS_RESULT : UDINT := 5;
 STATUS_LAST_ERROR : UDINT := 6;
 STATUS_SOCKET_ERROR : UDINT := 7;
 STATUS_EXCEPTION : UDINT := 8;
 STATUS_WRITE_UNCERTAIN : UDINT := 9;
 STATUS_RECONNECTS : UDINT := 11;
 STATUS_FUNCTION : UDINT := 18;
END_VAR



VAR
 engineOpenCommand : UDINT := 1;
 engineDevice : STRING(127);
 engineSerialBaud : UDINT;
 engineSerialParity : BYTE;
 engineSerialBits : BYTE;
 engineSerialStops : BYTE;
 engineSerialRs485 : UDINT;
END_VAR

VAR_INPUT
    
 in_enable : BOOL := TRUE;
END_VAR

VAR_OUTPUT
 stats : ClientStats;
END_VAR
```

## ModbusMaster.ClientRTU

Linux serial/RTU configuration. Changing serial parameters recreates the context. Explicit unit ID 1..247 is required on requests.

```iecst
{attribute 'monitoring_display' := 'toString'}
{attribute 'no_assign'}
FUNCTION_BLOCK ClientRTU EXTENDS ClientBase
VAR_INPUT
    
 in_device : STRING(127) := '/dev/ttyUSB0';
    
 in_baudRate : UDINT := 9600;
    
 in_parity : BYTE := 0; 
    
 in_dataBits : BYTE := 8;
    
 in_stopBits : BYTE := 1; 
    
 in_rs485 : BOOL; 

    
 in_reconnectDelay : TIME := T#100MS;
    
 in_holdUncertainWrites : BOOL := FALSE;
END_VAR
VAR
 lastDevice : STRING(127);
 lastBaud : UDINT;
 lastParity : BYTE;
 lastBits : BYTE;
 lastStops : BYTE;
 lastRs485 : BOOL;
 lastRetry : TIME;
END_VAR
```

## ModbusMaster.ClientTCP

TCP connection configuration. Changing endpoint, connect timeout or retry delay recreates its context. Inherits ClientBase statistics and monitoring string.

```iecst
{attribute 'monitoring_display' := 'toString'}
{attribute 'no_assign'}
FUNCTION_BLOCK ClientTCP EXTENDS ClientBase
VAR_INPUT
    {attribute 'symbol' := 'none'}
    
	in_ipAddress: ARRAY[0..3] OF BYTE; 
    {attribute 'symbol' := 'none'}
    
	in_port: UINT := 502; 
    {attribute 'symbol' := 'none'}
    
	in_baudrate: UINT := 0; 
END_VAR
VAR_INPUT

    
in_connectTimeout : TIME := T#2S;
    
in_reconnectDelay : TIME := T#100MS; 
    
in_holdUncertainWrites : BOOL := FALSE;
END_VAR

VAR
engineEndpointIP : DWORD;
engineEndpointPort : UINT;
engineConfigConnect : UDINT;
engineConfigRetry : UDINT;
END_VAR
```

## ModbusMaster.ReqReadCoil

Read request using the indicated BOOL/UINT array and shared RequestBase inputs. Successful replies update only the selected slice; inspect out_validData/out_stale.

```iecst
{attribute 'no_assign'}
FUNCTION_BLOCK ReqReadCoil EXTENDS RequestBase
VAR_IN_OUT
	
    {attribute 'symbol' := 'none'}
    
	data: ARRAY[*] OF BOOL;
END_VAR
```

## ModbusMaster.ReqReadDiscrete

Read request using the indicated BOOL/UINT array and shared RequestBase inputs. Successful replies update only the selected slice; inspect out_validData/out_stale.

```iecst
{attribute 'no_assign'}
FUNCTION_BLOCK ReqReadDiscrete EXTENDS RequestBase
VAR_IN_OUT
	
    {attribute 'symbol' := 'none'}
    
	data: ARRAY[*] OF BOOL;
END_VAR
```

## ModbusMaster.ReqReadHolding

Read request using the indicated BOOL/UINT array and shared RequestBase inputs. Successful replies update only the selected slice; inspect out_validData/out_stale.

```iecst
{attribute 'no_assign'}
FUNCTION_BLOCK ReqReadHolding EXTENDS RequestBase
VAR_IN_OUT
	
    {attribute 'symbol' := 'none'}
    
	data: ARRAY[*] OF UINT;
END_VAR
```

## ModbusMaster.ReqReadInput

Read request using the indicated BOOL/UINT array and shared RequestBase inputs. Successful replies update only the selected slice; inspect out_validData/out_stale.

```iecst
{attribute 'no_assign'}
FUNCTION_BLOCK ReqReadInput EXTENDS RequestBase
VAR_IN_OUT
	
    {attribute 'symbol' := 'none'}
    
	data: ARRAY[*] OF UINT;
END_VAR
```

## ModbusMaster.RequestBase

Abstract registered request. Quantity is clamped to available data capacity; zero disables scheduling. Concrete blocks supply data type and function code.

```iecst
{attribute 'no_assign'}
FUNCTION_BLOCK ABSTRACT RequestBase
VAR_INPUT
    {attribute 'symbol' := 'none'}
    
	client: REFERENCE TO ClientBase; 
    {attribute 'symbol' := 'none'}
    
	in_startAddr: UINT;
    {attribute 'symbol' := 'none'}
    
	in_quantity: UINT;
    {attribute 'symbol' := 'none'}
    
	in_dataOffset: UINT; 
    {attribute 'symbol' := 'none'}
    
	in_unitId: BYTE := 0;
    {attribute 'symbol' := 'none'}
    
	in_timeout: SYSTIME := 0; 
    {attribute 'symbol' := 'none'}
    
    in_minDelay: TIME := T#10MS; 
    {attribute 'symbol' := 'none'}
    
	in_prioritySetpoint: INT := 50; 
    {attribute 'symbol' := 'none'}
    
    in_priorityCurrent: INT; 
    {attribute 'symbol' := 'none'}
    
	stats: RequestStats; 

END_VAR
VAR
    {attribute 'symbol' := 'none'}
    
	dataCapacity: UINT;
END_VAR

VAR
engineFunction : BYTE;
engineTransactionQuantity : UINT;
engineTransactionDataIndex : UINT;
engineInFlight : BOOL;
engineReadComplete : BOOL;
engineCopyAllowed : BOOL;
engineWriteHold : BOOL;
engineRequestStartMilliseconds : ULINT;
engineDataIndex : DINT;
engineCallResult : UDINT;
END_VAR

VAR_OUTPUT
    
out_errorCode : UDINT;
    
out_socketError : UDINT;
    
out_writeUncertain : BOOL;
    
out_validData : BOOL;
    
out_dataAgeMs : ULINT;
    
out_stale : BOOL := TRUE;
    
out_parameterError : BOOL;
END_VAR

VAR_INPUT
    
in_staleAfter : TIME := T#2S;
END_VAR
```

## ModbusMaster.RequestStats

Per-request history, communication flags and 100 ms display indicators. Maintained by request processing; temporary disable retains historical counters.

```iecst
{attribute 'monitoring_display' := 'toString'}
{attribute 'no_assign'}
FUNCTION_BLOCK RequestStats
VAR_INPUT
    
	lastErrorId: Error; 
    
	lastExceptionCode: ExceptionCodes; 
    
	lastValidDuration: UDINT; 
    
	longestValidDuration: UDINT; 
    
	interval: UDINT; 
    
	offlineCnt: UINT; 
    
	doneCnt: UDINT; 
    
	errorCnt: UDINT; 
    
	doneCntRst: UDINT; 
    
	errorCntRst: UDINT; 
    
	sinceLastExec: UDINT; 
    
	timeoutCnt: UDINT;
    
	reqLength: UINT; 
END_VAR
VAR_OUTPUT
    
	executeLight: BOOL; 
    
	reqDoneLight: BOOL; 
    
	reqErrorLight: BOOL; 
    
	reqBusyLight: BOOL; 
    
	online: BOOL; 
    
	offline: BOOL; 
    
	active: BOOL; 
    
	executeMbFb: BOOL;
END_VAR
VAR
    {attribute 'symbol' := 'none'}
	doneIndicatorDelay: TOF;
    {attribute 'symbol' := 'none'}
	errorIndicatorDelay: TOF;
    {attribute 'symbol' := 'none'}
	busyIndicatorDelay: TOF;
    {attribute 'symbol' := 'none'}
	executeIndicatorDelay: TOF;
	toString: STRING(64);
    {attribute 'symbol' := 'none'}
	executeTrig: R_TRIG; 
	{attribute 'symbol' := 'none'}
	offlineTrig: R_TRIG; 
    {attribute 'symbol' := 'none'}
	lastRequestStartMicroseconds: SYSTIME; 
    {attribute 'symbol' := 'none'}
	currentTimeMicroseconds: SYSTIME;
	_execute: BOOL; 
	_reqDone: BOOL; 
	_reqBusy: BOOL; 
	_reqError: BOOL; 
END_VAR

VAR CONSTANT
    {attribute 'symbol' := 'none'}
	INDICATOR_HOLD_TIME: TIME:= T#100MS; 
END_VAR
VAR_INPUT
    
engineResponseSeen : BOOL;
    
engineLastSuccessMs : ULINT;
END_VAR

VAR_INPUT
 sentCnt : UDINT;
 replyCnt : UDINT;
 exceptionCnt : UDINT;
 totalValidDuration : ULINT; // Sum of successful transport transaction durations, milliseconds.
END_VAR
VAR
 previousOnline : BOOL;
END_VAR
```

## ModbusMaster.ReqWriteCoil

Cyclic write request. Values are copied at submission; writeNow changes eligibility/hold state. See uncertain-write policy in USER-GUIDE.md.

```iecst
{attribute 'no_assign'}
FUNCTION_BLOCK ReqWriteCoil EXTENDS RequestBase
VAR_IN_OUT
	
    {attribute 'symbol' := 'none'}
    
	data: ARRAY[*] OF BOOL;
END_VAR
```

## ModbusMaster.ReqWriteHolding

Cyclic write request. Values are copied at submission; writeNow changes eligibility/hold state. See uncertain-write policy in USER-GUIDE.md.

```iecst
{attribute 'no_assign'}
FUNCTION_BLOCK ReqWriteHolding EXTENDS RequestBase
VAR_IN_OUT
	
    {attribute 'symbol' := 'none'}
    
	data: ARRAY[*] OF UINT;
END_VAR
```

## ModbusMaster.To_IPAddress

Return four BYTE IPv4 octets as the ClientTCP address array.

```iecst
FUNCTION To_IPAddress : ARRAY[0..3] OF BYTE
VAR_INPUT
    
	byte1: BYTE;
    
	byte2: BYTE;
    
	byte3: BYTE;
    
	byte4: BYTE;
END_VAR
```

## ModbusSlave.ModbusSlave

TCP server: four memory arrays, eight peers, up to 2000 entries/table. Array bounds define protocol addresses. Dirty remote writes are protected until PLC pull. Mapping changes require in_reset. No RTU server is provided.

```iecst
{attribute 'no_assign'}
FUNCTION_BLOCK ModbusSlave
VAR_IN_OUT
    
 aDiscreteInputsMemory : ARRAY[*] OF BOOL;
    
 aCoilsMemory : ARRAY[*] OF BOOL;
    
 aInputRegistersMemory : ARRAY[*] OF UINT;
    
 aHoldingRegistersMemory : ARRAY[*] OF UINT;
END_VAR
VAR_INPUT
    
 in_enable : BOOL := TRUE;
    
 in_reset : BOOL;
    
 in_reconnectDelay : TIME := T#100MS;
    
 interfaceName : WSTRING; 
    
 in_ipAddress : DWORD; 
    
 port : UINT := 502;
END_VAR
VAR_OUTPUT
    
 out_running : BOOL;
    
 out_error : BOOL;
    
 out_errorId : Error;
    
 out_parameterError : BOOL;
    
 out_socketError : UDINT;
    
 out_connectedClients : UINT;
    
 out_requestsReceived : UDINT;
    
 out_repliesSent : UDINT;
    
 out_exceptionReplies : UDINT;
END_VAR
VAR
 serverHandle : UDINT;
 serverStatus : ARRAY[0..23] OF UDINT;
 serverIO : ARRAY[0..1999] OF WORD;
 nowUs : SYSTIME;
    
 nowMs : ULINT;
 lastIP : DWORD;
 lastPort : UINT;
 lastRetry : TIME;
 callResult : UDINT;
 tableIndex : BYTE;
 itemIndex : DINT;
 tableStart : UINT;
 tableCount : UINT;
END_VAR
```

## ModbusSlave.SlaveTCP

TCP server: four memory arrays, eight peers, up to 2000 entries/table. Array bounds define protocol addresses. Dirty remote writes are protected until PLC pull. Mapping changes require in_reset. No RTU server is provided.

```iecst
{attribute 'no_assign'}
FUNCTION_BLOCK SlaveTCP
VAR_IN_OUT
    
 aDiscreteInputsMemory : ARRAY[*] OF BOOL;
    
 aCoilsMemory : ARRAY[*] OF BOOL;
    
 aInputRegistersMemory : ARRAY[*] OF UINT;
    
 aHoldingRegistersMemory : ARRAY[*] OF UINT;
END_VAR
VAR_INPUT
    
 in_enable : BOOL := TRUE;
    
 in_reset : BOOL;
    
 in_reconnectDelay : TIME := T#100MS;
    
 interfaceName : WSTRING; 
    
 in_ipAddress : DWORD; 
    
 port : UINT := 502;
END_VAR
VAR_OUTPUT
    
 out_running : BOOL;
    
 out_error : BOOL;
    
 out_errorId : Error;
    
 out_parameterError : BOOL;
    
 out_socketError : UDINT;
    
 out_connectedClients : UINT;
    
 out_requestsReceived : UDINT;
    
 out_repliesSent : UDINT;
    
 out_exceptionReplies : UDINT;
END_VAR
VAR
 serverHandle : UDINT;
 serverStatus : ARRAY[0..23] OF UDINT;
 serverIO : ARRAY[0..1999] OF WORD;
 nowUs : SYSTIME;
    
 nowMs : ULINT;
 lastIP : DWORD;
 lastPort : UINT;
 lastRetry : TIME;
 callResult : UDINT;
 tableIndex : BYTE;
 itemIndex : DINT;
 tableStart : UINT;
 tableCount : UINT;
END_VAR
```

## ClientBase.addRequest

Register unique non-null request pointer, max 100. Duplicate registration is ignored. Overflow sets registrationFull.

```iecst
METHOD PUBLIC addRequest
VAR_INPUT
	request: POINTER TO RequestBase;
END_VAR
VAR
	requestIndex : DINT := 0;

END_VAR
```

## ClientBase.FB_exit

Lifecycle resource release. context hooks close their owned handle. Use public release for application shutdown.

```iecst
METHOD FB_exit : BOOL
VAR_INPUT
    
 bInCopyCode : BOOL;
END_VAR
```

## ClientBase.FB_reinit

Clear handles/registry or request execution state after instance reinitialization. Does not guarantee online-change correctness.

```iecst
METHOD FB_reinit : BOOL
VAR
 requestIndex : DINT;
END_VAR
```

## ClientBase.callEngine

Internal synchronous ABI adapter with WORD transfer buffer and 24-word status storage. RTU open repurposes fields to pass serial path/configuration.

```iecst
METHOD callEngine : UDINT
VAR_INPUT
    
 command : UDINT;
END_VAR

VAR
 deviceBytes : POINTER TO BYTE;
 deviceLength : UINT;
 deviceIndex : DINT;
END_VAR
```

## ClientBase.processCycle

Refresh scan lease, read completed results, process request completions, acknowledge result and select next transaction. Transport I/O progresses during the owning PLC call.

```iecst
METHOD processCycle
VAR
 callResult : UDINT;
END_VAR
```

## ClientBase.ensureContext

Allocate/configure/enable a context. A nonzero handle does not imply connectivity. Old components are rejected with error 259.

```iecst
METHOD PROTECTED ensureContext : BOOL
VAR
 callResult : UDINT;
END_VAR
```

## ClientBase.releaseContext

Close context, cancel active request, mark requests offline and invalidate cached read data. Returns TRUE. Does not disable in_enable; an enabled client can reopen.

```iecst
METHOD releaseContext : BOOL
VAR
 requestIndex : DINT;
END_VAR
```

## ClientBase.selectNextRequest

Select lowest current priority among eligible unheld requests; oldest age breaks ties. Minimum start delay applies. No zero-priority prerequisite.

```iecst
METHOD PROTECTED selectNextRequest
VAR
 requestIndex : DINT;
 selectedRequestIndex : DINT;
 selectedPriority : INT;
 oldestRequestAgeMilliseconds : UDINT;
END_VAR
```

## ClientBase.updateDiagnostics

Publish transport state, errno, last result history and reconnect-attempt count. Mark requests offline on connection loss.

```iecst
METHOD PROTECTED updateDiagnostics
```

## ClientBase.updateStatistics

Rebuild the client summary from each registered RequestStats. State counts are restricted to active requests; historic counters include inactive ones. Publish the common monitoring string and compatibility counters.

```iecst
METHOD PROTECTED updateStatistics
VAR
 requestIndex : DINT;
END_VAR
```

## ClientBase.processAllRequests

Dispatch all registered non-null request methods; guarded against empty/invalid count.

```iecst
METHOD processAllRequests
VAR_INPUT
END_VAR
VAR
	requestIndex: DINT; 
END_VAR
```

## ClientBase.recreateClient

Release current context so next enabled scan reopens with current settings. Affects every request using that connection.

```iecst
METHOD ABSTRACT recreateClient
VAR_INPUT
END_VAR
```

## ClientBase.release

Disable client input and release its context. Passing in_enable TRUE on a subsequent call resumes it.

```iecst
METHOD release : BOOL
```

## ClientBase.resetStats

Clear success/error/send/reply/timeout/exception/offline counters and successful-duration history. Client version delegates to each request and refreshes totals. Connection state and data freshness are preserved.

```iecst
METHOD resetStats
VAR
 requestIndex : DINT;
END_VAR
```

## ClientBase.setAllRequestsOffline

Force registered request statistics offline. Used when connection disappears or context is released.

```iecst
METHOD PROTECTED setAllRequestsOffline : BOOL
VAR_INPUT
END_VAR
VAR
	requestIndex: DINT;
END_VAR
```

## ClientBase.setupClient

Return whether a context handle exists. Does not open a context or prove connection success.

```iecst
METHOD setupClient : BOOL
VAR_INPUT
END_VAR
```

## ClientBase.activeIndex

Read active registry index or -1. Setting valid index flags that request execute; it does not bypass scheduler eligibility.

```iecst
PROPERTY activeIndex : DINT
```

## ClientBase.activeReqCnt

Private count of active registered requests.

```iecst
PROPERTY PRIVATE activeReqCnt : UINT
```

## ClientBase.allRequestsComplete

Legacy private flag check: FALSE for no requests or any execution/completion/error flag present.

```iecst
{attribute 'symbol' := 'none'}
PROPERTY PRIVATE allRequestsComplete : BOOL
```

## ClientBase.onlineCnt

Legacy count of registered online flags. Client.stats.onlineCount uses active requests only.

```iecst
{attribute 'symbol' := 'none'}
PROPERTY onlineCnt : DINT
```

## ClientBase.requestExecuting

Private activeIndex <> -1 test.

```iecst
{attribute 'symbol' := 'none'}
PROPERTY PRIVATE requestExecuting : BOOL
```

## ClientRTU.recreateClient

Release current context so next enabled scan reopens with current settings. Affects every request using that connection.

```iecst
METHOD recreateClient
```

## ClientBase.toString

Shared client string property returning stats.toString. Used by both concrete client monitoring displays.

```iecst
PROPERTY toString : STRING(64)
```

## ClientTCP.recreateClient

Release current context so next enabled scan reopens with current settings. Affects every request using that connection.

```iecst
METHOD recreateClient
```

## ReqReadCoil.processRequest

Concrete request adapter performs bounds validation and transfers its typed slice through processTransaction; abstract on RequestBase. Called by scheduler.

```iecst
METHOD processRequest
```

## ReqReadCoil.recreateRequest

Clear request in-flight state; if it owns the active transaction, recreates the client connection. Returns TRUE.

```iecst
METHOD recreateRequest : BOOL
```

## ReqReadDiscrete.processRequest

Concrete request adapter performs bounds validation and transfers its typed slice through processTransaction; abstract on RequestBase. Called by scheduler.

```iecst
METHOD processRequest
```

## ReqReadDiscrete.recreateRequest

Clear request in-flight state; if it owns the active transaction, recreates the client connection. Returns TRUE.

```iecst
METHOD recreateRequest : BOOL
```

## ReqReadHolding.processRequest

Concrete request adapter performs bounds validation and transfers its typed slice through processTransaction; abstract on RequestBase. Called by scheduler.

```iecst
METHOD processRequest
```

## ReqReadHolding.recreateRequest

Clear request in-flight state; if it owns the active transaction, recreates the client connection. Returns TRUE.

```iecst
METHOD recreateRequest : BOOL
```

## ReqReadInput.processRequest

Concrete request adapter performs bounds validation and transfers its typed slice through processTransaction; abstract on RequestBase. Called by scheduler.

```iecst
METHOD processRequest
```

## ReqReadInput.recreateRequest

Clear request in-flight state; if it owns the active transaction, recreates the client connection. Returns TRUE.

```iecst
METHOD recreateRequest : BOOL
```

## RequestBase.busy

Set stats.reqBusy and return the assigned flag.

```iecst
METHOD busy : BOOL
VAR_INPUT
    
	in: BOOL;
END_VAR
```

## RequestBase.done

Set stats.reqDone and restore configured priority on success.

```iecst
METHOD done
VAR_INPUT
	
    
	in: BOOL;
END_VAR
```

## RequestBase.err

Set error identity before triggering counter update; apply 10/40/90 consecutive-error priority backoff.

```iecst
METHOD err
VAR_INPUT
	
    
	in: BOOL;
    
	errorId: Error; 
    
	exceptionCode: ExceptionCodes; 
END_VAR
VAR
	priorityMultiplier: INT; 
END_VAR
```

## RequestBase.FB_reinit

Clear handles/registry or request execution state after instance reinitialization. Does not guarantee online-change correctness.

```iecst
METHOD FB_reinit : BOOL
```

## RequestBase.invalidateData

Invalidate/stale cached read data without clearing its application array.

```iecst
METHOD PUBLIC invalidateData
```

## RequestBase.finishRequest

Map a completed result and write uncertainty, collect transport timing/read age, update reply/exception/timeout counters and completion flags. Successful reads become valid; errors retain old array values.

```iecst
METHOD finishRequest
VAR_INPUT
    
 result : UDINT;
END_VAR
VAR
 mapped : Error;
 ex : ExceptionCodes;
 duration : UDINT;
END_VAR
```

## RequestBase.processTransaction

Submit the selected request or consume its buffered result. Record accepted-send counter and refresh data freshness. Normally invoked by the client through concrete processRequest.

```iecst
METHOD processTransaction
VAR_INPUT
    
 functionCode : BYTE;
END_VAR
```

## RequestBase.processRequest

Concrete request adapter performs bounds validation and transfers its typed slice through processTransaction; abstract on RequestBase. Called by scheduler.

```iecst
METHOD ABSTRACT processRequest
VAR_INPUT
END_VAR
```

## RequestBase.recreateRequest

Clear request in-flight state; if it owns the active transaction, recreates the client connection. Returns TRUE.

```iecst
METHOD ABSTRACT recreateRequest : BOOL
```

## RequestBase.replyTimeout

Internal microsecond timeout calculation. Request milliseconds override client TIME, then baud/data-rate formula. C submission rounds to milliseconds.

```iecst
PROPERTY PROTECTED replyTimeout : UDINT
```

## RequestStats.resetStats

Clear success/error/send/reply/timeout/exception/offline counters and successful-duration history. Client version delegates to each request and refreshes totals. Connection state and data freshness are preserved.

```iecst
METHOD resetStats
VAR_INPUT
END_VAR
```

## RequestStats.setClientOffline

Count a real online-to-offline transition, clear response evidence and force offline. Returns TRUE.

```iecst
METHOD setClientOffline : BOOL
VAR_INPUT
END_VAR
```

## RequestStats.setToString

Update OK:<doneCnt>/Er:<errorCnt> monitoring text, returning TRUE.

```iecst
METHOD PRIVATE setToString : BOOL
VAR_INPUT
END_VAR
```

## RequestStats.execute

Execution state property. Setter refuses execution while completion/error flags remain set.

```iecst
PROPERTY execute : BOOL
```

## RequestStats.reqBusy

Underlying request busy flag; normal application code inspects rather than drives it.

```iecst
PROPERTY reqBusy : BOOL
```

## RequestStats.reqDone

On successful executing completion, increment saturated success counters, clear errors and execution, update display. Transport supplies duration.

```iecst
PROPERTY reqDone : BOOL
```

## RequestStats.reqError

On failed executing completion, increment saturated error counters and clear execution. Timeout/exception classification is handled by finishRequest.

```iecst
PROPERTY reqError : BOOL
```

## ReqWriteCoil.processRequest

Concrete request adapter performs bounds validation and transfers its typed slice through processTransaction; abstract on RequestBase. Called by scheduler.

```iecst
METHOD processRequest
```

## ReqWriteCoil.recreateRequest

Clear request in-flight state; if it owns the active transaction, recreates the client connection. Returns TRUE.

```iecst
METHOD recreateRequest : BOOL
```

## ReqWriteCoil.writeNow

Release uncertain-write hold and set priority zero. Does not send synchronously or make the cyclic write block single-shot.

```iecst
METHOD writeNow : BOOL
VAR_INPUT
END_VAR
```

## ReqWriteHolding.processRequest

Concrete request adapter performs bounds validation and transfers its typed slice through processTransaction; abstract on RequestBase. Called by scheduler.

```iecst
METHOD processRequest
```

## ReqWriteHolding.recreateRequest

Clear request in-flight state; if it owns the active transaction, recreates the client connection. Returns TRUE.

```iecst
METHOD recreateRequest : BOOL
```

## ReqWriteHolding.writeNow

Release uncertain-write hold and set priority zero. Does not send synchronously or make the cyclic write block single-shot.

```iecst
METHOD writeNow : BOOL
VAR_INPUT
END_VAR
```

## ModbusSlave.FB_exit

Lifecycle resource release. context hooks close their owned handle. Use public release for application shutdown.

```iecst
METHOD FB_exit : BOOL
VAR_INPUT
    
 bInCopyCode : BOOL;
END_VAR
```

## ModbusSlave.FB_reinit

Clear handles/registry or request execution state after instance reinitialization. Does not guarantee online-change correctness.

```iecst
METHOD FB_reinit : BOOL
```

## ModbusSlave.serverCall

Private synchronous server ABI adapter using server staging/status arrays.

```iecst
METHOD PRIVATE serverCall : UDINT
VAR_INPUT
    
 command : UDINT;
END_VAR
```

## SlaveTCP.FB_exit

Lifecycle resource release. context hooks close their owned handle. Use public release for application shutdown.

```iecst
METHOD FB_exit : BOOL
VAR_INPUT
    
 bInCopyCode : BOOL;
END_VAR
```

## SlaveTCP.FB_reinit

Clear handles/registry or request execution state after instance reinitialization. Does not guarantee online-change correctness.

```iecst
METHOD FB_reinit : BOOL
```

## SlaveTCP.serverCall

Private synchronous server ABI adapter using server staging/status arrays.

```iecst
METHOD PRIVATE serverCall : UDINT
VAR_INPUT
    
 command : UDINT;
END_VAR
```

## activeIndex.Get

Get accessor for activeIndex; see the owning property description for semantics and side effects.

```iecst
VAR
	requestIndex: DINT; 
END_VAR
```

## activeIndex.Set

Set accessor for activeIndex; see the owning property description for semantics and side effects.

```iecst

```

## activeReqCnt.Get

Get accessor for activeReqCnt; see the owning property description for semantics and side effects.

```iecst
VAR
	requestIndex : DINT; 
	cnt: UINT;
END_VAR
```

## allRequestsComplete.Get

Get accessor for allRequestsComplete; see the owning property description for semantics and side effects.

```iecst
VAR
	requestIndex : DINT;
END_VAR
```

## onlineCnt.Get

Get accessor for onlineCnt; see the owning property description for semantics and side effects.

```iecst
VAR
	requestIndex : DINT; 
	cnt: UINT;
END_VAR
```

## requestExecuting.Get

Get accessor for requestExecuting; see the owning property description for semantics and side effects.

```iecst

```

## toString.Get

Get accessor for toString; see the owning property description for semantics and side effects.

```iecst

```

## replyTimeout.Get

Get accessor for replyTimeout; see the owning property description for semantics and side effects.

```iecst

```

## execute.Get

Get accessor for execute; see the owning property description for semantics and side effects.

```iecst

```

## execute.Set

Set accessor for execute; see the owning property description for semantics and side effects.

```iecst

```

## reqBusy.Get

Get accessor for reqBusy; see the owning property description for semantics and side effects.

```iecst

```

## reqBusy.Set

Set accessor for reqBusy; see the owning property description for semantics and side effects.

```iecst

```

## reqDone.Get

Get accessor for reqDone; see the owning property description for semantics and side effects.

```iecst

```

## reqDone.Set

Set accessor for reqDone; see the owning property description for semantics and side effects.

```iecst

```

## reqError.Get

Get accessor for reqError; see the owning property description for semantics and side effects.

```iecst

```

## reqError.Set

Set accessor for reqError; see the owning property description for semantics and side effects.

```iecst

```

## ModbusMaster.ClientStats

Aggregate data structure: sums all registered request history, counts active communication states and calculates a weighted successful-duration mean. See USER-GUIDE.md for exact semantics.

```iecst
TYPE ClientStats :
STRUCT
 doneCnt : ULINT; // Sum over every registered request, including inactive requests.
 errorCnt : ULINT;
 sentCnt : ULINT;
 replyCnt : ULINT;
 exceptionCnt : ULINT;
 timeoutCnt : ULINT;
 offlineCnt : ULINT; // Sum of request online-to-offline transitions.
 requestCount : UINT;
 activeCount : UINT;
 onlineCount : UINT;
 offlineCount : UINT;
 unknownCount : UINT; // Active, neither online nor offline yet.
 busyCount : UINT;
 staleCount : UINT; // Active read requests only.
 heldWriteCount : UINT;
 totalValidDuration : ULINT; // Milliseconds, all successful requests.
 averageValidDuration : ULINT; // Weighted mean = totalValidDuration / doneCnt.
 longestValidDuration : UDINT; // Maximum request maximum, milliseconds.
 active : BOOL;
 online : BOOL; // At least one active request and all active requests online.
 offline : BOOL; // At least one active request and all active requests explicitly offline.
 toString : STRING(64);
END_STRUCT
END_TYPE
```