Implement FC01/FC02 across Protocol, transports, tests, and docs

- Add ReadCoilStatus (FC01) and ReadInputStatus (FC02) to Protocol NVI API and hooks\n- Implement FC01/FC02 for TCPIPProtocol and RTUProtocol; add DummyProtocol overrides\n- Extend tests with FC01/FC02 coverage for TCP/IP, Dummy, and RTU endpoints\n- Update README, TECHNICAL_DOCS, CLAUDE guidance, and regenerate Doxygen HTML output

Author: gcardi

CLAUDE.md

@@ -73,7 +73,7 @@ Protocol (abstract base, Modbus.h)
     └── DummyProtocol     — No-op stub for tests (ModbusDummy.h)
 ```
 
-**`Modbus::Master::Protocol`** is the abstract base. Subclasses implement protected `Do*()` virtual hooks for transport I/O and connection management. Public methods (FC03, FC04, FC06, FC16, FC22) are implemented in the base class on top of those hooks.
+**`Modbus::Master::Protocol`** is the abstract base. Subclasses implement protected `Do*()` virtual hooks for transport I/O and connection management. Public methods (FC01, FC02, FC03, FC04, FC06, FC16, FC22) are implemented in the base class on top of those hooks.
 
 **`Modbus::Master::SessionManager`** is an RAII guard: calls `Open()` on construction, `Close()` on destruction.
 
@@ -89,7 +89,7 @@ Protocol (abstract base, Modbus.h)
 
 ## Test Suite
 
-`Test/ModbusTest.cpp` uses **Boost.Test 1.89** (`boost/test/included/unit_test.hpp`). A `ServerFixture` global fixture starts an embedded Modbus slave on `127.0.0.1:5020` in a `std::thread` before tests run and stops it after. Tests cover FC03, FC04, FC06, FC16, FC22, and exception handling.
+`Test/ModbusTest.cpp` uses **Boost.Test 1.89** (`boost/test/included/unit_test.hpp`). A `ServerFixture` global fixture starts an embedded Modbus slave on `127.0.0.1:5020` in a `std::thread` before tests run and stops it after. Tests cover FC01, FC02, FC03, FC04, FC06, FC16, FC22, and exception handling across TCP/IP, Dummy, and RTU endpoints.
 
 CMake test build details and known pitfalls (SysInit.o linking, PCH2 force-include) are documented in [Test/README-cmake.md](Test/README-cmake.md) and [TECHNICAL_DOCS.md](TECHNICAL_DOCS.md).
 
@@ -100,23 +100,23 @@ CMake test build details and known pitfalls (SysInit.o linking, PCH2 force-inclu
 - Correct: `_D("Modbus TCP")`, `String(DEFAULT_MODBUS_TCPIP_HOST)`
 - Incorrect: `_D(DEFAULT_MODBUS_TCPIP_HOST)`
 
- **Non-Virtual Interface (NVI) Pattern:**
- 
- This project implements the NVI pattern throughout the protocol hierarchy to enforce consistent API contracts across all transports:
- 
- - **Public methods** (Open, Close, ReadHoldingRegisters, PresetMultipleRegisters, etc.) are non-virtual concrete functions in the base class.
- - **Virtual hooks** follow the "`Do`" prefix naming convention: DoOpen, DoClose, DoReadHoldingRegisters, DoPresetMultipleRegisters, etc.
- - **Hook placement:** Virtual hooks are declared in the `protected` section of abstract base classes.
- - **Subclass responsibility:** Concrete transport subclasses (RTUProtocol, TCPProtocolIndy, TCPProtocolWinSock, etc.) implement ONLY the Do…() virtual hooks; they do NOT override public methods.
- - **Benefit:** This enforces contract validation, logging, and error handling at the base class level, ensuring consistency across RTU, TCP, UDP, and Dummy transports.
- 
- Example: To add a new transport (e.g., SerialProtocolCustom extending RTUProtocol), override only the Do…() methods—never override the public API.
- 
- **Namespaces:**
- 
- - `Modbus::` — types, exceptions, `Context`
- - `Modbus::Master::` — `Protocol`, `SessionManager`, all transport classes
- - `Modbus::Utils::` — serial enumeration (`SerEnum.h`)
+**Non-Virtual Interface (NVI) Pattern:**
+
+This project implements the NVI pattern throughout the protocol hierarchy to enforce consistent API contracts across all transports:
+
+- **Public methods** (Open, Close, ReadHoldingRegisters, PresetMultipleRegisters, etc.) are non-virtual concrete functions in the base class.
+- **Virtual hooks** follow the "`Do`" prefix naming convention: DoOpen, DoClose, DoReadHoldingRegisters, DoPresetMultipleRegisters, etc.
+- **Hook placement:** Virtual hooks are declared in the `protected` section of abstract base classes.
+- **Subclass responsibility:** Concrete transport subclasses (RTUProtocol, TCPProtocolIndy, TCPProtocolWinSock, etc.) implement ONLY the Do…() virtual hooks; they do NOT override public methods.
+- **Benefit:** This enforces contract validation, logging, and error handling at the base class level, ensuring consistency across RTU, TCP, UDP, and Dummy transports.
+
+Example: To add a new transport (e.g., SerialProtocolCustom extending RTUProtocol), override only the Do…() methods—never override the public API.
+
+**Namespaces:**
+
+- `Modbus::` — types, exceptions, `Context`
+- `Modbus::Master::` — `Protocol`, `SessionManager`, all transport classes
+- `Modbus::Utils::` — serial enumeration (`SerEnum.h`)
 
 **Compiler compatibility:** `[[noreturn]]` attribute placement differs between BCC32 and BCC32C/BCC64 — see existing exception class declarations for the guarded pattern.
 

Modbus.cpp

@@ -163,6 +163,24 @@ void Protocol::Close()
 //    DoReadCoilStatus
 //    DoReadInputStatus
 
+void Protocol::DoReadCoilStatus( Context const & /* Context */,
+                                 CoilAddrType /*StartAddr*/,
+                                 CoilCountType /*PointCount*/,
+                                 CoilDataType* /*Data*/ )
+{
+    RaiseFunctionCodeNotImplementedException( FunctionCode::ReadCoilStatus );
+}
+//---------------------------------------------------------------------------
+
+void Protocol::DoReadInputStatus( Context const & /* Context */,
+                                  CoilAddrType /*StartAddr*/,
+                                  CoilCountType /*PointCount*/,
+                                  CoilDataType* /*Data*/ )
+{
+    RaiseFunctionCodeNotImplementedException( FunctionCode::ReadInputStatus );
+}
+//---------------------------------------------------------------------------
+
 void Protocol::DoReadHoldingRegisters( Context const & /* Context */,
                                        RegAddrType /*StartAddr*/,
                                        RegCountType /*PointCount*/,

Modbus.h

@@ -386,8 +386,47 @@ class Protocol {
     /** @brief Returns a human-readable string describing the protocol parameters (host:port, COM port settings, etc.). */
     String GetProtocolParamsStr() const { return DoGetProtocolParamsStr(); }
 
-//    ReadCoilStatus
-//    ReadInputStatus
+    /**
+     * @brief Reads one or more coil statuses (FC01).
+     * @param Context    Transaction context (slave address, transaction ID).
+     * @param StartAddr  Zero-based start coil address.
+     * @param PointCount Number of coils to read (max 2000 by Modbus spec).
+     * @param[out] Data  Pointer to packed coil bytes; required size is
+     *                   @c (PointCount + 7) / 8 bytes.
+     *
+     * @details Coil values are bit-packed in LSB-first order per Modbus spec.
+     *  Bit 0 of @c Data[0] corresponds to @p StartAddr.
+     *
+     * @throws EIllegalDataAddress if the address or count is out of range on the slave.
+     * @throws EBaseException on communication error or timeout.
+     */
+    void ReadCoilStatus( Context const & Context,
+                         CoilAddrType StartAddr, CoilCountType PointCount,
+                         CoilDataType* Data )
+    {
+        DoReadCoilStatus( Context, StartAddr, PointCount, Data );
+    }
+
+    /**
+     * @brief Reads one or more discrete input statuses (FC02).
+     * @param Context    Transaction context (slave address, transaction ID).
+     * @param StartAddr  Zero-based start input address.
+     * @param PointCount Number of discrete inputs to read (max 2000 by Modbus spec).
+     * @param[out] Data  Pointer to packed input bytes; required size is
+     *                   @c (PointCount + 7) / 8 bytes.
+     *
+     * @details Input values are bit-packed in LSB-first order per Modbus spec.
+     *  Bit 0 of @c Data[0] corresponds to @p StartAddr.
+     *
+     * @throws EIllegalDataAddress if the address or count is out of range on the slave.
+     * @throws EBaseException on communication error or timeout.
+     */
+    void ReadInputStatus( Context const & Context,
+                          CoilAddrType StartAddr, CoilCountType PointCount,
+                          CoilDataType* Data )
+    {
+        DoReadInputStatus( Context, StartAddr, PointCount, Data );
+    }
 
     /**
      * @brief Reads one or more holding registers (FC03).
@@ -532,7 +571,15 @@ class Protocol {
      *  4. Extract the register values and populate the Data buffer.
      */
 
-//    DoReadInputStatus
+    virtual void DoReadCoilStatus( Context const & Context,
+                                   CoilAddrType StartAddr,
+                                   CoilCountType PointCount,
+                                   CoilDataType* Data ) = 0;
+    virtual void DoReadInputStatus( Context const & Context,
+                                    CoilAddrType StartAddr,
+                                    CoilCountType PointCount,
+                                    CoilDataType* Data ) = 0;
+
     virtual void DoReadHoldingRegisters( Context const & Context,
                                          RegAddrType StartAddr,
                                          RegCountType PointCount,

ModbusDummy.h

@@ -54,8 +54,14 @@ class DummyProtocol : public Protocol {
     virtual void DoClose() override { active_ = false; }
     virtual bool DoIsConnected() const override { return active_; }
 
-//    DoReadCoilStatus
-//    DoReadInputStatus
+    virtual void DoReadCoilStatus( Context const & Context,
+                                   CoilAddrType StartAddr,
+                                   CoilCountType PointCount,
+                                   CoilDataType* Data ) override {}
+    virtual void DoReadInputStatus( Context const & Context,
+                                    CoilAddrType StartAddr,
+                                    CoilCountType PointCount,
+                                    CoilDataType* Data ) override {}
 
     virtual void DoReadHoldingRegisters( Context const & Context,
                                          RegAddrType StartAddr,

ModbusRTU.cpp

@@ -201,6 +201,70 @@ bool RTUProtocol::DoIsConnected() const
 //    RTUProtocol::DoReadCoilStatus
 //    RTUProtocol::DoReadInputStatus
 
+void RTUProtocol::ReadBits( FunctionCode FnCode, Context const & Context,
+                            CoilAddrType StartAddr, CoilCountType PointCount,
+                            CoilDataType* Data )
+{
+    if ( PointCount == 0 || PointCount > 2000 ) {
+        throw EContextException(
+            Context, _D( "Too many points have been requested" )
+        );
+    }
+
+    FrameCont TxFrame;
+    const FrameCont::size_type ExpectedByteCount( ( PointCount + 7 ) / 8 );
+    const FrameCont::size_type ExpectedRxFramelength( ExpectedByteCount + 5 );
+    FrameCont RxFrame;
+
+    RxFrame.reserve( ExpectedRxFramelength );
+    TxFrame.reserve( 8 );
+
+    back_insert_iterator<FrameCont> TxFrameBkInsIt( TxFrame );
+    *TxFrameBkInsIt++ = Context.GetSlaveAddr();
+    *TxFrameBkInsIt++ = static_cast<RegDataType>( FnCode );
+    TxFrameBkInsIt =
+        WriteAddressPointCountPair( TxFrameBkInsIt, StartAddr, PointCount );
+    WriteCRC( TxFrameBkInsIt, TxFrame.begin(), TxFrame.end() );
+
+    SendAndReceiveFrames(
+        Context, TxFrame, back_inserter( RxFrame ),
+        ExpectedRxFramelength, retryCount_
+    );
+
+    FrameCont::const_iterator RxInIt = RxFrame.begin();
+
+    const FrameCont::size_type RxByteCount =
+        static_cast<FrameCont::size_type>( *RxInIt++ );
+
+    if ( RxByteCount != ExpectedByteCount ) {
+        throw EContextException( Context, _D( "Byte count mismatch" ) );
+    }
+
+    for ( FrameCont::size_type Idx = 0; Idx < RxByteCount; ++Idx ) {
+        *Data++ = *RxInIt++;
+    }
+}
+//---------------------------------------------------------------------------
+
+void RTUProtocol::DoReadCoilStatus( Context const & Context,
+                                    CoilAddrType StartAddr,
+                                    CoilCountType PointCount,
+                                    CoilDataType* Data )
+{
+    ReadBits( FunctionCode::ReadCoilStatus, Context, StartAddr,
+              PointCount, Data );
+}
+//---------------------------------------------------------------------------
+
+void RTUProtocol::DoReadInputStatus( Context const & Context,
+                                     CoilAddrType StartAddr,
+                                     CoilCountType PointCount,
+                                     CoilDataType* Data )
+{
+    ReadBits( FunctionCode::ReadInputStatus, Context, StartAddr,
+              PointCount, Data );
+}
+
 //---------------------------------------------------------------------------
 
 void RTUProtocol::ReadRegisters( FunctionCode FnCode, Context const & Context,

ModbusRTU.h

@@ -156,8 +156,14 @@ class RTUProtocol : public Protocol {
     virtual void DoClose() override;
     virtual bool DoIsConnected() const override;
 
-//    DoReadCoilStatus
-//    DoReadInputStatus
+    virtual void DoReadCoilStatus( Context const & Context,
+                                   CoilAddrType StartAddr,
+                                   CoilCountType PointCount,
+                                   CoilDataType* Data ) override;
+    virtual void DoReadInputStatus( Context const & Context,
+                                    CoilAddrType StartAddr,
+                                    CoilCountType PointCount,
+                                    CoilDataType* Data ) override;
 
     virtual void DoReadHoldingRegisters( Context const & Context,
                                          RegAddrType StartAddr,
@@ -258,6 +264,10 @@ class RTUProtocol : public Protocol {
                         RegAddrType StartAddr, RegCountType PointCount,
                         RegDataType* Data );
 
+    void ReadBits( FunctionCode FnCode, Context const & Context,
+                   CoilAddrType StartAddr, CoilCountType PointCount,
+                   CoilDataType* Data );
+
 public:
     /**
      * @brief Computes and appends the Modbus CRC16 to an output iterator range.

ModbusTCP_IP.cpp

@@ -260,9 +260,76 @@ String TCPIPProtocol::DoGetProtocolParamsStr() const
 //---------------------------------------------------------------------------
 
 //    TCPIPProtocol::DoReadCoilStatus
+void TCPIPProtocol::ReadBits( FunctionCode FnCode, Context const & Context,
+                              CoilAddrType StartAddr, CoilCountType PointCount,
+                              CoilDataType* Data )
+{
+    if ( PointCount == 0 || PointCount > 2000 ) {
+        throw EContextException( Context, _D( "Invalid point count" ) );
+    }
+
+    const uint8_t ExpectedByteCount =
+        static_cast<uint8_t>( ( PointCount + 7 ) / 8 );
+
+    // Send
+    TBytes OutBuffer;
+    SetLength( OutBuffer, GetBMAPHeaderLength() + 1 + GetAddressPointCountPairLength() );
+    int Idx = WriteBMAPHeader( OutBuffer, 0, Context );
+    OutBuffer[Idx++] = static_cast<RegDataType>( FnCode );
+    Idx = WriteAddressPointCountPair( OutBuffer, Idx, StartAddr, PointCount );
+    DoInputBufferClear();
+    DoWrite( OutBuffer );
+
+    // Receive
+    TBytes ReplyBMAPBuffer;
+    SetLength( ReplyBMAPBuffer, GetBMAPHeaderLength() );
+    DoRead( ReplyBMAPBuffer, GetLength( ReplyBMAPBuffer ) );
+
+    // Validate BMAP and payload function code
+    RaiseExceptionIfBMAPIsNotEQ( Context, OutBuffer, ReplyBMAPBuffer );
+    TBytes ReplyBuffer;
+    SetLength( ReplyBuffer, GetBMAPDataLength( ReplyBMAPBuffer ) - 1 );
+    DoRead( ReplyBuffer, GetLength( ReplyBuffer ) );
+    RaiseExceptionIfReplyIsNotValid( Context, ReplyBuffer, FnCode );
+
+    if ( GetLength( ReplyBuffer ) < 2 ) {
+        throw EContextException( Context, _D( "Invalid reply length" ) );
+    }
+
+    const uint8_t ByteCount = ReplyBuffer[1];
+    if ( ByteCount != ExpectedByteCount || GetLength( ReplyBuffer ) != ByteCount + 2 ) {
+        throw EContextException( Context, _D( "Byte count mismatch" ) );
+    }
+
+    for ( uint8_t I = 0; I < ByteCount; ++I ) {
+        Data[I] = ReplyBuffer[2 + I];
+    }
+}
 //---------------------------------------------------------------------------
 
 //    TCPIPProtocol::DoReadInputStatus
+void TCPIPProtocol::DoReadCoilStatus( Context const & Context,
+                                      CoilAddrType StartAddr,
+                                      CoilCountType PointCount,
+                                      CoilDataType* Data )
+{
+    RaiseExceptionIfIsNotConnected( _D( "ReadCoilStatus failed" ) );
+
+    ReadBits( FunctionCode::ReadCoilStatus, Context, StartAddr,
+              PointCount, Data );
+}
+//---------------------------------------------------------------------------
+
+void TCPIPProtocol::DoReadInputStatus( Context const & Context,
+                                       CoilAddrType StartAddr,
+                                       CoilCountType PointCount,
+                                       CoilDataType* Data )
+{
+    RaiseExceptionIfIsNotConnected( _D( "ReadInputStatus failed" ) );
+
+    ReadBits( FunctionCode::ReadInputStatus, Context, StartAddr,
+              PointCount, Data );
+}
 //---------------------------------------------------------------------------
 
 void TCPIPProtocol::ReadRegisters( FunctionCode FnCode, Context const & Context,

ModbusTCP_IP.h

@@ -71,7 +71,8 @@ namespace Master {
  *  - Builds Modbus request frames with proper MBAP headers.
  *  - Delegates I/O to pure virtual DoWrite() and DoRead() hooks.
  *  - Validates MBAP response headers (transaction ID, protocol ID = 0, unit identifier).
- *  - Implements all Modbus function codes (FC03, FC04, FC06, FC16, FC22) inherited by TCP/UDP transports.
+ *  - Implements all Modbus function codes (FC01, FC02, FC03, FC04, FC06, FC16, FC22)
+ *    inherited by TCP/UDP transports.
  *
  *  **NVI Architecture:**
  *  - Concrete TCP/UDP subclasses (e.g., TCPProtocolIndy, UDPProtocolWinSock) override the
@@ -86,7 +87,8 @@ namespace Master {
  *    - DoRead()  — reads exactly @p Length bytes from the response stream or datagram cache.
  *    (other Do…() methods for FC03, FC04, etc. are defined in Protocol and inherited here).
  *
- *  All Modbus function codes supported by this library (FC03, FC04, FC06, FC16, FC22) are
+ *  All Modbus function codes supported by this library
+ *  (FC01, FC02, FC03, FC04, FC06, FC16, FC22) are
  *  fully implemented in Protocol and inherited by TCPIPProtocol; concrete TCP/UDP subclasses
  *  do not need to reimplement function code logic.
  */
@@ -142,8 +144,14 @@ class TCPIPProtocol : public Protocol {
      */
     virtual void DoRead( TBytes& InBuffer, size_t Length ) = 0;
 
-//    DoReadCoilStatus
-//    DoReadInputStatus
+    virtual void DoReadCoilStatus( Context const & Context,
+                                   CoilAddrType StartAddr,
+                                   CoilCountType PointCount,
+                                   CoilDataType* Data ) override;
+    virtual void DoReadInputStatus( Context const & Context,
+                                    CoilAddrType StartAddr,
+                                    CoilCountType PointCount,
+                                    CoilDataType* Data ) override;
     virtual void DoReadHoldingRegisters( Context const & Context,
                                          RegAddrType StartAddr,
                                          RegCountType PointCount,
@@ -217,6 +225,10 @@ class TCPIPProtocol : public Protocol {
                         RegAddrType StartAddr, RegCountType PointCount,
                         RegDataType* Data );
 
+    void ReadBits( FunctionCode FnCode, Context const & Context,
+                   CoilAddrType StartAddr, CoilCountType PointCount,
+                   CoilDataType* Data );
+
 protected:
     template<typename T>
     static uint16_t GetLength( T const & Data ) {