modbus-connect/src/function-codes/read-holding-registers.ts

Modbus RTU over Web Serial and Node.js SerialPort

// src/function-codes/read-holding-registers.ts

import { ReadHoldingRegistersResponse } from '../types/modbus-types.js';

const FUNCTION_CODE = 0x03;
const MIN_QUANTITY = 1;
const MAX_QUANTITY = 125;
const REQUEST_SIZE = 5;
const RESPONSE_HEADER_SIZE = 2;
const UINT16_SIZE = 2;

/**
 * Строит PDU-запрос для чтения holding регистров
 * @param startAddress - начальный адрес
 * @param quantity - количество регистров (1-125)
 * @returns Uint8Array
 */
export function buildReadHoldingRegistersRequest(
  startAddress: number,
  quantity: number
): Uint8Array {
  if ((quantity | 0) !== quantity || quantity < MIN_QUANTITY || quantity > MAX_QUANTITY) {
    throw new RangeError(`Quantity must be integer ${MIN_QUANTITY}-${MAX_QUANTITY}`);
  }

  const buffer = new ArrayBuffer(REQUEST_SIZE);
  const view = new DataView(buffer);

  view.setUint8(0, FUNCTION_CODE);
  view.setUint16(1, startAddress, false); // Big-endian
  view.setUint16(3, quantity, false); // Big-endian

  return new Uint8Array(buffer);
}

/**
 * Разбирает PDU-ответ с holding регистрами
 * @param pdu
 * @returns number[] - массив значений регистров
 */
export function parseReadHoldingRegistersResponse(pdu: Uint8Array): ReadHoldingRegistersResponse {
  if (!(pdu instanceof Uint8Array)) {
    throw new TypeError('PDU must be Uint8Array');
  }

  const pduLength = pdu.length;
  if (pduLength < RESPONSE_HEADER_SIZE) {
    throw new Error('PDU too short');
  }

  if (pdu[0] !== FUNCTION_CODE) {
    throw new Error(`Invalid function code: expected 0x03, got 0x${pdu[0]?.toString(16)}`);
  }

  const byteCount = pdu[1]!;
  const expectedLength = byteCount + RESPONSE_HEADER_SIZE;

  if (pduLength !== expectedLength) {
    throw new Error(`Invalid length: expected ${expectedLength}, got ${pduLength}`);
  }

  if (byteCount === 0) {
    return [];
  }

  const buffer = pdu.buffer || pdu;
  const byteOffset = (pdu.byteOffset || 0) + RESPONSE_HEADER_SIZE;
  const registerCount = byteCount / UINT16_SIZE;
  const registers: number[] = new Array(registerCount);

  if (byteOffset % UINT16_SIZE === 0) {
    const uint16View = new Uint16Array(buffer, byteOffset, registerCount);
    for (let i = 0; i < registerCount; i++) {
      registers[i] = uint16View[i]!;
    }
  } else {
    const view = new DataView(
      buffer,
      byteOffset - RESPONSE_HEADER_SIZE,
      byteCount + RESPONSE_HEADER_SIZE
    );
    for (let i = 0; i < registerCount; i++) {
      registers[i] = view.getUint16(RESPONSE_HEADER_SIZE + i * UINT16_SIZE, false);
    }
  }

  return registers;
}