@flux-control/effect-teco-westinghouse-inverter
    Preparing search index...

    Class TecoInverterService

    Effect service for interacting with a Teco/Westinghouse A510 inverter over Modbus.

    Instantiate with TecoInverterService.Default and provide the appropriate transport layer (RtuTransportService or AsciiTransportService).

    TecoInverterService.Default

    Hierarchy

    • {
          a510CheckMonitor: (
              deviceId: number,
          ) => {
              read: () => Effect<A510CheckMonitor, ModbusError | ParseError, never>;
          };
          analogIn1Monitor: (
              deviceId: number,
          ) => {
              read: () => Effect<AnalogInputPercent, ModbusError | ParseError, never>;
          };
          analogIn2Monitor: (
              deviceId: number,
          ) => {
              read: () => Effect<AnalogInputPercent, ModbusError | ParseError, never>;
          };
          analogOut1Command: (
              deviceId: number,
          ) => {
              read: () => Effect<Voltage, ModbusError | ParseError, never>;
              update: (
                  ...args: [value: Voltage],
              ) => Effect<void, ModbusError | ParseError, never>;
          };
          analogOut1Monitor: (
              deviceId: number,
          ) => { read: () => Effect<Voltage, ModbusError | ParseError, never> };
          analogOut2Command: (
              deviceId: number,
          ) => {
              read: () => Effect<Voltage, ModbusError | ParseError, never>;
              update: (
                  ...args: [value: Voltage],
              ) => Effect<void, ModbusError | ParseError, never>;
          };
          analogOut2Monitor: (
              deviceId: number,
          ) => { read: () => Effect<Voltage, ModbusError | ParseError, never> };
          dcBusVoltageCommandMonitor: (
              deviceId: number,
          ) => { read: () => Effect<DCBusVoltage, ModbusError | ParseError, never> };
          digitalInStateMonitor: (
              deviceId: number,
          ) => {
              read: () => Effect<
                  DigitalInStateMonitorFlags,
                  ModbusError
                  | ParseError,
                  never,
              >;
          };
          digitalOutCommand: (
              deviceId: number,
          ) => {
              read: () => Effect<
                  DigitalOutCommandFlags,
                  ModbusError
                  | ParseError,
                  never,
              >;
              update: (
                  ...args: [patch: Readonly<Record<string, boolean | undefined>>],
              ) => Effect<void, ModbusError | ParseError, never>;
          };
          digitalOutStateMonitor: (
              deviceId: number,
          ) => {
              read: () => Effect<
                  DigitalOutStateMonitorFlags,
                  ModbusError
                  | ParseError,
                  never,
              >;
          };
          errorDescriptionMonitor: (
              deviceId: number,
          ) => {
              read: () => Effect<
                  ErrorDescriptionMonitor,
                  ModbusError
                  | ParseError,
                  never,
              >;
          };
          frequencyCommand: (
              deviceId: number,
          ) => {
              read: () => Effect<FrequencyHz, ModbusError | ParseError, never>;
              update: (
                  ...args: [value: FrequencyHz],
              ) => Effect<void, ModbusError | ParseError, never>;
          };
          frequencyCommandMonitor: (
              deviceId: number,
          ) => { read: () => Effect<FrequencyHz, ModbusError | ParseError, never> };
          operationCommand: (
              deviceId: number,
          ) => {
              read: () => Effect<CommandWordFlags, ModbusError | ParseError, never>;
              update: (
                  ...args: [patch: Readonly<Record<string, boolean | undefined>>],
              ) => Effect<void, ModbusError | ParseError, never>;
          };
          outputCurrentMonitor: (
              deviceId: number,
          ) => { read: () => Effect<CurrentAmps, ModbusError | ParseError, never> };
          outputFrequencyMonitor: (
              deviceId: number,
          ) => { read: () => Effect<FrequencyHz, ModbusError | ParseError, never> };
          speedLimitCommand: (
              deviceId: number,
          ) => {
              read: () => Effect<SpeedLimitPercent, ModbusError | ParseError, never>;
              update: (
                  ...args: [value: SpeedLimitPercent],
              ) => Effect<void, ModbusError | ParseError, never>;
          };
          stateMonitor: (
              deviceId: number,
          ) => {
              read: () => Effect<StateMonitorFlags, ModbusError | ParseError, never>;
          };
          torqueCommand: (
              deviceId: number,
          ) => {
              read: () => Effect<TorquePercent, ModbusError | ParseError, never>;
              update: (
                  ...args: [value: TorquePercent],
              ) => Effect<void, ModbusError | ParseError, never>;
          };
          warningDescriptionMonitor: (
              deviceId: number,
          ) => {
              read: () => Effect<
                  WarningDescriptionMonitor,
                  ModbusError
                  | ParseError,
                  never,
              >;
          };
      } & {}
      • TecoInverterService
    Index
    constructor
    a510CheckMonitor analogIn1Monitor analogIn2Monitor analogOut1Command analogOut1Monitor analogOut2Command analogOut2Monitor dcBusVoltageCommandMonitor digitalInStateMonitor digitalOutCommand digitalOutStateMonitor errorDescriptionMonitor frequencyCommand frequencyCommandMonitor operationCommand outputCurrentMonitor outputFrequencyMonitor speedLimitCommand stateMonitor torqueCommand warningDescriptionMonitor
    mockDevice

    • Parameters

      • _: {
            a510CheckMonitor: (
                deviceId: number,
            ) => {
                read: () => Effect<A510CheckMonitor, ModbusError | ParseError, never>;
            };
            analogIn1Monitor: (
                deviceId: number,
            ) => {
                read: () => Effect<AnalogInputPercent, ModbusError | ParseError, never>;
            };
            analogIn2Monitor: (
                deviceId: number,
            ) => {
                read: () => Effect<AnalogInputPercent, ModbusError | ParseError, never>;
            };
            analogOut1Command: (
                deviceId: number,
            ) => {
                read: () => Effect<Voltage, ModbusError | ParseError, never>;
                update: (
                    ...args: [value: Voltage],
                ) => Effect<void, ModbusError | ParseError, never>;
            };
            analogOut1Monitor: (
                deviceId: number,
            ) => { read: () => Effect<Voltage, ModbusError | ParseError, never> };
            analogOut2Command: (
                deviceId: number,
            ) => {
                read: () => Effect<Voltage, ModbusError | ParseError, never>;
                update: (
                    ...args: [value: Voltage],
                ) => Effect<void, ModbusError | ParseError, never>;
            };
            analogOut2Monitor: (
                deviceId: number,
            ) => { read: () => Effect<Voltage, ModbusError | ParseError, never> };
            dcBusVoltageCommandMonitor: (
                deviceId: number,
            ) => { read: () => Effect<DCBusVoltage, ModbusError | ParseError, never> };
            digitalInStateMonitor: (
                deviceId: number,
            ) => {
                read: () => Effect<
                    DigitalInStateMonitorFlags,
                    ModbusError
                    | ParseError,
                    never,
                >;
            };
            digitalOutCommand: (
                deviceId: number,
            ) => {
                read: () => Effect<
                    DigitalOutCommandFlags,
                    ModbusError
                    | ParseError,
                    never,
                >;
                update: (
                    ...args: [patch: Readonly<Record<string, boolean | undefined>>],
                ) => Effect<void, ModbusError | ParseError, never>;
            };
            digitalOutStateMonitor: (
                deviceId: number,
            ) => {
                read: () => Effect<
                    DigitalOutStateMonitorFlags,
                    ModbusError
                    | ParseError,
                    never,
                >;
            };
            errorDescriptionMonitor: (
                deviceId: number,
            ) => {
                read: () => Effect<
                    ErrorDescriptionMonitor,
                    ModbusError
                    | ParseError,
                    never,
                >;
            };
            frequencyCommand: (
                deviceId: number,
            ) => {
                read: () => Effect<FrequencyHz, ModbusError | ParseError, never>;
                update: (
                    ...args: [value: FrequencyHz],
                ) => Effect<void, ModbusError | ParseError, never>;
            };
            frequencyCommandMonitor: (
                deviceId: number,
            ) => { read: () => Effect<FrequencyHz, ModbusError | ParseError, never> };
            operationCommand: (
                deviceId: number,
            ) => {
                read: () => Effect<CommandWordFlags, ModbusError | ParseError, never>;
                update: (
                    ...args: [patch: Readonly<Record<string, boolean | undefined>>],
                ) => Effect<void, ModbusError | ParseError, never>;
            };
            outputCurrentMonitor: (
                deviceId: number,
            ) => { read: () => Effect<CurrentAmps, ModbusError | ParseError, never> };
            outputFrequencyMonitor: (
                deviceId: number,
            ) => { read: () => Effect<FrequencyHz, ModbusError | ParseError, never> };
            speedLimitCommand: (
                deviceId: number,
            ) => {
                read: () => Effect<SpeedLimitPercent, ModbusError | ParseError, never>;
                update: (
                    ...args: [value: SpeedLimitPercent],
                ) => Effect<void, ModbusError | ParseError, never>;
            };
            stateMonitor: (
                deviceId: number,
            ) => {
                read: () => Effect<StateMonitorFlags, ModbusError | ParseError, never>;
            };
            torqueCommand: (
                deviceId: number,
            ) => {
                read: () => Effect<TorquePercent, ModbusError | ParseError, never>;
                update: (
                    ...args: [value: TorquePercent],
                ) => Effect<void, ModbusError | ParseError, never>;
            };
            warningDescriptionMonitor: (
                deviceId: number,
            ) => {
                read: () => Effect<
                    WarningDescriptionMonitor,
                    ModbusError
                    | ParseError,
                    never,
                >;
            };
        }
        • a510CheckMonitor: (
              deviceId: number,
          ) => {
              read: () => Effect<A510CheckMonitor, ModbusError | ParseError, never>;
          }

          Read the drive series/model identification. Register 0x252F. Returns a string such as "A510(s)", "E510(s)", "L510(s)", or "F510".

          const model = yield* inverter.a510CheckMonitor(1).read(); // "A510(s)"
        • analogIn1Monitor: (
              deviceId: number,
          ) => {
              read: () => Effect<AnalogInputPercent, ModbusError | ParseError, never>;
          }

          Read analog input 1 as a percentage of full scale. Register 0x252C. Range 0.0–100.0% (wire: 0–1000, 0.1%/count).

          const ai1 = yield* inverter.analogIn1Monitor(1).read(); // AnalogInputPercent
        • analogIn2Monitor: (
              deviceId: number,
          ) => {
              read: () => Effect<AnalogInputPercent, ModbusError | ParseError, never>;
          }

          Read analog input 2 as a percentage of full scale. Register 0x252D. Range 0.0–100.0% (wire: 0–1000, 0.1%/count).

          const ai2 = yield* inverter.analogIn2Monitor(1).read(); // AnalogInputPercent
        • analogOut1Command: (
              deviceId: number,
          ) => {
              read: () => Effect<Voltage, ModbusError | ParseError, never>;
              update: (
                  ...args: [value: Voltage],
              ) => Effect<void, ModbusError | ParseError, never>;
          }

          Set analog output 1 target voltage. Register 0x2505. Range 0.00–10.00 V (wire: 0–1000, 0.01 V/count).

          yield* inverter.analogOut1Command(1).update(5.0); // 5.00 V
        • analogOut1Monitor: (
              deviceId: number,
          ) => { read: () => Effect<Voltage, ModbusError | ParseError, never> }

          Read the actual voltage on analog output 1. Register 0x252A. Range 0.00–10.00 V (wire: 0–1000, 0.01 V/count).

          const voltage = yield* inverter.analogOut1Monitor(1).read(); // Voltage
        • analogOut2Command: (
              deviceId: number,
          ) => {
              read: () => Effect<Voltage, ModbusError | ParseError, never>;
              update: (
                  ...args: [value: Voltage],
              ) => Effect<void, ModbusError | ParseError, never>;
          }

          Set analog output 2 target voltage. Register 0x2506. Range 0.00–10.00 V (wire: 0–1000, 0.01 V/count).

          yield* inverter.analogOut2Command(1).update(7.5); // 7.50 V
        • analogOut2Monitor: (
              deviceId: number,
          ) => { read: () => Effect<Voltage, ModbusError | ParseError, never> }

          Read the actual voltage on analog output 2. Register 0x252B. Range 0.00–10.00 V (wire: 0–1000, 0.01 V/count).

          const voltage = yield* inverter.analogOut2Monitor(1).read(); // Voltage
        • dcBusVoltageCommandMonitor: (
              deviceId: number,
          ) => { read: () => Effect<DCBusVoltage, ModbusError | ParseError, never> }

          Read the DC bus voltage in volts. Register 0x2526. Range 0.0–1000.0 V (wire: 0–10000, 0.1 V/count).

          const dcBus = yield* inverter.dcBusVoltageCommandMonitor(1).read(); // DCBusVoltage
        • digitalInStateMonitor: (
              deviceId: number,
          ) => {
              read: () => Effect<
                  DigitalInStateMonitorFlags,
                  ModbusError
                  | ParseError,
                  never,
              >;
          }

          Read the state of the eight digital input terminals S1–S8. Register 0x2522. Each bit reflects the live logic level of one terminal.

          const inputs = yield* inverter.digitalInStateMonitor(1).read();
          if (inputs.s1) { /* S1 is active */ }
        • digitalOutCommand: (
              deviceId: number,
          ) => {
              read: () => Effect<
                  DigitalOutCommandFlags,
                  ModbusError
                  | ParseError,
                  never,
              >;
              update: (
                  ...args: [patch: Readonly<Record<string, boolean | undefined>>],
              ) => Effect<void, ModbusError | ParseError, never>;
          }

          Control digital output terminals (RY1, RY2, pulse train). Register 0x2507.

          Uses read-modify-write semantics: only the fields present in the patch are written back, preserving the current state of unchanged bits.

          yield* inverter.digitalOutCommand(1).update({ ry1: true, ry2: false });
        • digitalOutStateMonitor: (
              deviceId: number,
          ) => {
              read: () => Effect<
                  DigitalOutStateMonitorFlags,
                  ModbusError
                  | ParseError,
                  never,
              >;
          }

          Read the state of the digital output terminals (RY1, RY2, pulse). Register 0x2529. Each bit reflects the live logic level of one output.

          const outputs = yield* inverter.digitalOutStateMonitor(1).read();
          if (outputs.ry1) { /* RY1 relay is energized */ }
        • errorDescriptionMonitor: (
              deviceId: number,
          ) => {
              read: () => Effect<
                  ErrorDescriptionMonitor,
                  ModbusError
                  | ParseError,
                  never,
              >;
          }

          Read the current fault/error code and get a human-readable description. Register 0x2521. Returns a string such as "OC (Over-current)" or "UV (Under-voltage)".

          const err = yield* inverter.errorDescriptionMonitor(1).read(); // "OC (Over-current)"
        • frequencyCommand: (
              deviceId: number,
          ) => {
              read: () => Effect<FrequencyHz, ModbusError | ParseError, never>;
              update: (
                  ...args: [value: FrequencyHz],
              ) => Effect<void, ModbusError | ParseError, never>;
          }

          Set the target output frequency in Hz. Register 0x2502. Range 0.00–599.00 Hz (wire: 0–59900, 0.01 Hz/count).

          yield* inverter.frequencyCommand(1).update(50.0); // 50 Hz
          const freq = yield* inverter.frequencyCommand(1).read(); // FrequencyHz
        • frequencyCommandMonitor: (
              deviceId: number,
          ) => { read: () => Effect<FrequencyHz, ModbusError | ParseError, never> }

          Read the frequency command currently in effect (after ramps, limits, etc.). Register 0x2523. Returns a FrequencyHz value.

          const freq = yield* inverter.frequencyCommandMonitor(1).read(); // FrequencyHz
        • operationCommand: (
              deviceId: number,
          ) => {
              read: () => Effect<CommandWordFlags, ModbusError | ParseError, never>;
              update: (
                  ...args: [patch: Readonly<Record<string, boolean | undefined>>],
              ) => Effect<void, ModbusError | ParseError, never>;
          }

          Start/stop/reverse the inverter and signal external faults. Register 0x2501.

          Uses read-modify-write semantics: only the fields present in the patch are written back, preserving the current state of unchanged bits.

          // Run forward
          yield* inverter.operationCommand(1).update({ run: true });
          // Fault reset pulse
          yield* inverter.operationCommand(1).update({ faultReset: true });
          // Stop
          yield* inverter.operationCommand(1).update({ run: false });
        • outputCurrentMonitor: (
              deviceId: number,
          ) => { read: () => Effect<CurrentAmps, ModbusError | ParseError, never> }

          Read the inverter output current in amps. Register 0x2527. Range 0.0–6553.5 A (wire: 0–65535, 0.1 A/count).

          const current = yield* inverter.outputCurrentMonitor(1).read(); // CurrentAmps
        • outputFrequencyMonitor: (
              deviceId: number,
          ) => { read: () => Effect<FrequencyHz, ModbusError | ParseError, never> }

          Read the actual inverter output frequency. Register 0x2524. Returns a FrequencyHz value.

          const outFreq = yield* inverter.outputFrequencyMonitor(1).read(); // FrequencyHz
        • speedLimitCommand: (
              deviceId: number,
          ) => {
              read: () => Effect<SpeedLimitPercent, ModbusError | ParseError, never>;
              update: (
                  ...args: [value: SpeedLimitPercent],
              ) => Effect<void, ModbusError | ParseError, never>;
          }

          Set the speed limit as a percentage of nominal speed. Register 0x2504. Range –120–120% (wire: UInt16 two's complement, 1:1 mapping).

          yield* inverter.speedLimitCommand(1).update(100); // 100% speed limit
        • stateMonitor: (
              deviceId: number,
          ) => {
              read: () => Effect<StateMonitorFlags, ModbusError | ParseError, never>;
          }

          Read the current inverter operating state as individual flag fields. Register 0x2520. Flags include: run, reverse, fault, warning, zeroSpeed, underVoltage, overTorque, and more.

          const state = yield* inverter.stateMonitor(1).read();
          if (state.fault) { /* handle fault */ }
          if (state.run && !state.reverse) { /* running forward */ }
        • torqueCommand: (
              deviceId: number,
          ) => {
              read: () => Effect<TorquePercent, ModbusError | ParseError, never>;
              update: (
                  ...args: [value: TorquePercent],
              ) => Effect<void, ModbusError | ParseError, never>;
          }

          Set the torque limit / torque command as a percentage of rated torque. Register 0x2503. Range –100.0–100.0% (wire: UInt16 two's complement, ÷81.92).

          yield* inverter.torqueCommand(1).update(75.0); // 75% torque
          const torque = yield* inverter.torqueCommand(1).read(); // TorquePercent
        • warningDescriptionMonitor: (
              deviceId: number,
          ) => {
              read: () => Effect<
                  WarningDescriptionMonitor,
                  ModbusError
                  | ParseError,
                  never,
              >;
          }

          Read the current warning/alarm code and get a human-readable description. Register 0x2528. Returns a string such as "OV (Overvoltage)" or "No alarm".

          const warn = yield* inverter.warningDescriptionMonitor(1).read(); // "No alarm"

      Returns TecoInverterService

    a510CheckMonitor: (
        deviceId: number,
    ) => {
        read: () => Effect<A510CheckMonitor, ModbusError | ParseError, never>;
    }

    Read the drive series/model identification. Register 0x252F. Returns a string such as "A510(s)", "E510(s)", "L510(s)", or "F510".

    const model = yield* inverter.a510CheckMonitor(1).read(); // "A510(s)"
    analogIn1Monitor: (
        deviceId: number,
    ) => {
        read: () => Effect<AnalogInputPercent, ModbusError | ParseError, never>;
    }

    Read analog input 1 as a percentage of full scale. Register 0x252C. Range 0.0–100.0% (wire: 0–1000, 0.1%/count).

    const ai1 = yield* inverter.analogIn1Monitor(1).read(); // AnalogInputPercent
    analogIn2Monitor: (
        deviceId: number,
    ) => {
        read: () => Effect<AnalogInputPercent, ModbusError | ParseError, never>;
    }

    Read analog input 2 as a percentage of full scale. Register 0x252D. Range 0.0–100.0% (wire: 0–1000, 0.1%/count).

    const ai2 = yield* inverter.analogIn2Monitor(1).read(); // AnalogInputPercent
    analogOut1Command: (
        deviceId: number,
    ) => {
        read: () => Effect<Voltage, ModbusError | ParseError, never>;
        update: (
            ...args: [value: Voltage],
        ) => Effect<void, ModbusError | ParseError, never>;
    }

    Set analog output 1 target voltage. Register 0x2505. Range 0.00–10.00 V (wire: 0–1000, 0.01 V/count).

    yield* inverter.analogOut1Command(1).update(5.0); // 5.00 V
    analogOut1Monitor: (
        deviceId: number,
    ) => { read: () => Effect<Voltage, ModbusError | ParseError, never> }

    Read the actual voltage on analog output 1. Register 0x252A. Range 0.00–10.00 V (wire: 0–1000, 0.01 V/count).

    const voltage = yield* inverter.analogOut1Monitor(1).read(); // Voltage
    analogOut2Command: (
        deviceId: number,
    ) => {
        read: () => Effect<Voltage, ModbusError | ParseError, never>;
        update: (
            ...args: [value: Voltage],
        ) => Effect<void, ModbusError | ParseError, never>;
    }

    Set analog output 2 target voltage. Register 0x2506. Range 0.00–10.00 V (wire: 0–1000, 0.01 V/count).

    yield* inverter.analogOut2Command(1).update(7.5); // 7.50 V
    analogOut2Monitor: (
        deviceId: number,
    ) => { read: () => Effect<Voltage, ModbusError | ParseError, never> }

    Read the actual voltage on analog output 2. Register 0x252B. Range 0.00–10.00 V (wire: 0–1000, 0.01 V/count).

    const voltage = yield* inverter.analogOut2Monitor(1).read(); // Voltage
    dcBusVoltageCommandMonitor: (
        deviceId: number,
    ) => { read: () => Effect<DCBusVoltage, ModbusError | ParseError, never> }

    Read the DC bus voltage in volts. Register 0x2526. Range 0.0–1000.0 V (wire: 0–10000, 0.1 V/count).

    const dcBus = yield* inverter.dcBusVoltageCommandMonitor(1).read(); // DCBusVoltage
    digitalInStateMonitor: (
        deviceId: number,
    ) => {
        read: () => Effect<
            DigitalInStateMonitorFlags,
            ModbusError
            | ParseError,
            never,
        >;
    }

    Read the state of the eight digital input terminals S1–S8. Register 0x2522. Each bit reflects the live logic level of one terminal.

    const inputs = yield* inverter.digitalInStateMonitor(1).read();
    if (inputs.s1) { /* S1 is active */ }
    digitalOutCommand: (
        deviceId: number,
    ) => {
        read: () => Effect<
            DigitalOutCommandFlags,
            ModbusError
            | ParseError,
            never,
        >;
        update: (
            ...args: [patch: Readonly<Record<string, boolean | undefined>>],
        ) => Effect<void, ModbusError | ParseError, never>;
    }

    Control digital output terminals (RY1, RY2, pulse train). Register 0x2507.

    Uses read-modify-write semantics: only the fields present in the patch are written back, preserving the current state of unchanged bits.

    yield* inverter.digitalOutCommand(1).update({ ry1: true, ry2: false });
    digitalOutStateMonitor: (
        deviceId: number,
    ) => {
        read: () => Effect<
            DigitalOutStateMonitorFlags,
            ModbusError
            | ParseError,
            never,
        >;
    }

    Read the state of the digital output terminals (RY1, RY2, pulse). Register 0x2529. Each bit reflects the live logic level of one output.

    const outputs = yield* inverter.digitalOutStateMonitor(1).read();
    if (outputs.ry1) { /* RY1 relay is energized */ }
    errorDescriptionMonitor: (
        deviceId: number,
    ) => {
        read: () => Effect<
            ErrorDescriptionMonitor,
            ModbusError
            | ParseError,
            never,
        >;
    }

    Read the current fault/error code and get a human-readable description. Register 0x2521. Returns a string such as "OC (Over-current)" or "UV (Under-voltage)".

    const err = yield* inverter.errorDescriptionMonitor(1).read(); // "OC (Over-current)"
    frequencyCommand: (
        deviceId: number,
    ) => {
        read: () => Effect<FrequencyHz, ModbusError | ParseError, never>;
        update: (
            ...args: [value: FrequencyHz],
        ) => Effect<void, ModbusError | ParseError, never>;
    }

    Set the target output frequency in Hz. Register 0x2502. Range 0.00–599.00 Hz (wire: 0–59900, 0.01 Hz/count).

    yield* inverter.frequencyCommand(1).update(50.0); // 50 Hz
    const freq = yield* inverter.frequencyCommand(1).read(); // FrequencyHz
    frequencyCommandMonitor: (
        deviceId: number,
    ) => { read: () => Effect<FrequencyHz, ModbusError | ParseError, never> }

    Read the frequency command currently in effect (after ramps, limits, etc.). Register 0x2523. Returns a FrequencyHz value.

    const freq = yield* inverter.frequencyCommandMonitor(1).read(); // FrequencyHz
    operationCommand: (
        deviceId: number,
    ) => {
        read: () => Effect<CommandWordFlags, ModbusError | ParseError, never>;
        update: (
            ...args: [patch: Readonly<Record<string, boolean | undefined>>],
        ) => Effect<void, ModbusError | ParseError, never>;
    }

    Start/stop/reverse the inverter and signal external faults. Register 0x2501.

    Uses read-modify-write semantics: only the fields present in the patch are written back, preserving the current state of unchanged bits.

    // Run forward
    yield* inverter.operationCommand(1).update({ run: true });
    // Fault reset pulse
    yield* inverter.operationCommand(1).update({ faultReset: true });
    // Stop
    yield* inverter.operationCommand(1).update({ run: false });
    outputCurrentMonitor: (
        deviceId: number,
    ) => { read: () => Effect<CurrentAmps, ModbusError | ParseError, never> }

    Read the inverter output current in amps. Register 0x2527. Range 0.0–6553.5 A (wire: 0–65535, 0.1 A/count).

    const current = yield* inverter.outputCurrentMonitor(1).read(); // CurrentAmps
    outputFrequencyMonitor: (
        deviceId: number,
    ) => { read: () => Effect<FrequencyHz, ModbusError | ParseError, never> }

    Read the actual inverter output frequency. Register 0x2524. Returns a FrequencyHz value.

    const outFreq = yield* inverter.outputFrequencyMonitor(1).read(); // FrequencyHz
    speedLimitCommand: (
        deviceId: number,
    ) => {
        read: () => Effect<SpeedLimitPercent, ModbusError | ParseError, never>;
        update: (
            ...args: [value: SpeedLimitPercent],
        ) => Effect<void, ModbusError | ParseError, never>;
    }

    Set the speed limit as a percentage of nominal speed. Register 0x2504. Range –120–120% (wire: UInt16 two's complement, 1:1 mapping).

    yield* inverter.speedLimitCommand(1).update(100); // 100% speed limit
    stateMonitor: (
        deviceId: number,
    ) => {
        read: () => Effect<StateMonitorFlags, ModbusError | ParseError, never>;
    }

    Read the current inverter operating state as individual flag fields. Register 0x2520. Flags include: run, reverse, fault, warning, zeroSpeed, underVoltage, overTorque, and more.

    const state = yield* inverter.stateMonitor(1).read();
    if (state.fault) { /* handle fault */ }
    if (state.run && !state.reverse) { /* running forward */ }
    torqueCommand: (
        deviceId: number,
    ) => {
        read: () => Effect<TorquePercent, ModbusError | ParseError, never>;
        update: (
            ...args: [value: TorquePercent],
        ) => Effect<void, ModbusError | ParseError, never>;
    }

    Set the torque limit / torque command as a percentage of rated torque. Register 0x2503. Range –100.0–100.0% (wire: UInt16 two's complement, ÷81.92).

    yield* inverter.torqueCommand(1).update(75.0); // 75% torque
    const torque = yield* inverter.torqueCommand(1).read(); // TorquePercent
    warningDescriptionMonitor: (
        deviceId: number,
    ) => {
        read: () => Effect<
            WarningDescriptionMonitor,
            ModbusError
            | ParseError,
            never,
        >;
    }

    Read the current warning/alarm code and get a human-readable description. Register 0x2528. Returns a string such as "OV (Overvoltage)" or "No alarm".

    const warn = yield* inverter.warningDescriptionMonitor(1).read(); // "No alarm"

    • Constructs a SlaveDeviceDefinition suitable for use with a mock Modbus transport.

      Registers all command registers (0x2501–0x2507), monitor registers (0x2520–0x252F), and all parameter group registers (Groups 00–22) with default value 0.

      Parameters

      • deviceId: number

        The Modbus unit/slave ID this device should respond to

      Returns {}

      A SlaveDeviceDefinition ready to be passed to a mock transport layer

      import { MockTransportService } from "@flux-control/effect-modbus-rs";
      const mockLayer = MockTransportService.setDevices([
        TecoInverterService.mockDevice(1),
      ]);

    Settings
    Member Visibility

    On This Page
    Constructors
    Properties
    Methods