Implement P/F bit enforcement in ABM mode and UI frame support

Phase 2 HDLC ABM compliance improvements:

P/F Bit Enforcement:
- ABM mode: P bit only set on U-frames and keep-alive RR polls
- NRM mode: unchanged (P always set for marker passing)
- P-to-F propagation: RR response mirrors P bit from command
- Regular I-frames and RR acks no longer carry P bit in ABM

UI (Unnumbered Information) Frames:
- Added HDLC_U_FRAME_TYPE_UI constant (0x00)
- Public API: tiny_fd_send_ui_packet_to(), tiny_fd_send_ui_packet()
- RX handler: calls on_read_ui_cb callback when UI frame received
- UI frames work in any connection state (connectionless)
- Uses s_queue (service queue) for TX

Tests:
- Updated 6 existing tests for P/F bit expectation changes
- Added 7 new tests: P/F enforcement (4), UI send/receive (3)
- All 68 tests pass

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: lexus2k

src/proto/fd/tiny_fd.c

@@ -372,6 +372,7 @@ int tiny_fd_init(tiny_fd_handle_t *handle, tiny_fd_init_t *init)
     protocol->user_data = init->pdata;
     protocol->on_read_cb = init->on_read_cb;
     protocol->on_send_cb = init->on_send_cb;
+    protocol->on_read_ui_cb = init->on_read_ui_cb;
     protocol->on_connect_event_cb = init->on_connect_event_cb;
     protocol->log_frame_cb = init->log_frame_cb;
     protocol->send_timeout = init->send_timeout;
@@ -523,7 +524,19 @@ static uint8_t *tiny_fd_get_next_frame_to_send(tiny_fd_handle_t handle, int *len
     if ( data != NULL )
     {
         tiny_frame_header_t *header = (tiny_frame_header_t *)data;
-        header->control |= HDLC_P_BIT;
+        if ( handle->mode == TINY_FD_MODE_NRM )
+        {
+            // NRM: Always set P/F bit for marker passing
+            header->control |= HDLC_P_BIT;
+        }
+        else
+        {
+            // ABM: Set P/F only on U-frames (SABM, DISC, UA, DM always use P/F)
+            if ( (header->control & HDLC_U_FRAME_MASK) == HDLC_U_FRAME_BITS )
+            {
+                header->control |= HDLC_P_BIT;
+            }
+        }
         handle->last_marker_ts = tiny_millis();
         handle->peers[peer].last_sent_frame_ts = tiny_millis();
         __tiny_fd_log_frame(handle, TINY_FD_FRAME_DIRECTION_OUT, data, *len);
@@ -572,7 +585,7 @@ static void tiny_fd_connected_check_idle_timeout(tiny_fd_handle_t handle, uint8_
         // Nothing to send, all frames are confirmed, just send keep alive
         tiny_frame_header_t frame = {
             .address = __peer_to_address_field( handle, peer ),
-            .control = HDLC_S_FRAME_BITS | HDLC_S_FRAME_TYPE_RR |
+            .control = HDLC_S_FRAME_BITS | HDLC_S_FRAME_TYPE_RR | HDLC_P_BIT |
                (__i_queue_control_get_next_frame_to_receive(&handle->peers[peer].i_queue_control) << 5),
         };
         handle->peers[peer].ka_confirmed = 0;
@@ -823,6 +836,51 @@ int tiny_fd_send_packet(tiny_fd_handle_t handle, const void *data, int len, uint
 
 ///////////////////////////////////////////////////////////////////////////////
 
+int tiny_fd_send_ui_packet_to(tiny_fd_handle_t handle, uint8_t address, const void *data, int len)
+{
+    if ( handle == NULL || (data == NULL && len > 0) )
+    {
+        return TINY_ERR_INVALID_DATA;
+    }
+    if ( len > tiny_fd_queue_get_mtu( &handle->frames.s_queue ) )
+    {
+        return TINY_ERR_DATA_TOO_LARGE;
+    }
+    uint8_t peer;
+    if ( __is_secondary_station( handle ) && address == TINY_FD_PRIMARY_ADDR )
+    {
+        address = handle->addr;
+    }
+    peer = __address_field_to_peer( handle, (address << 2) | HDLC_E_BIT );
+    if ( peer == HDLC_INVALID_PEER_INDEX )
+    {
+        return TINY_ERR_UNKNOWN_PEER;
+    }
+
+    tiny_mutex_lock(&handle->frames.mutex);
+    tiny_fd_frame_info_t *slot = tiny_fd_queue_allocate( &handle->frames.s_queue, TINY_FD_QUEUE_U_FRAME, data, len );
+    if ( slot == NULL )
+    {
+        tiny_mutex_unlock(&handle->frames.mutex);
+        return TINY_ERR_FAILED;
+    }
+    slot->header.address = __peer_to_address_field( handle, peer );
+    slot->header.control = HDLC_U_FRAME_TYPE_UI | HDLC_U_FRAME_BITS;
+    LOG(TINY_LOG_DEB, "[%p] QUEUE UI-PUT: [%02X] [%02X] len=%d\n", handle, slot->header.address, slot->header.control, len);
+    tiny_events_set(&handle->events, FD_EVENT_TX_DATA_AVAILABLE);
+    tiny_mutex_unlock(&handle->frames.mutex);
+    return TINY_SUCCESS;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int tiny_fd_send_ui_packet(tiny_fd_handle_t handle, const void *data, int len)
+{
+    return tiny_fd_send_ui_packet_to(handle, TINY_FD_PRIMARY_ADDR, data, len);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
 int tiny_fd_buffer_size_by_mtu(int mtu, int window)
 {
     return tiny_fd_buffer_size_by_mtu_ex(0, mtu, window, HDLC_CRC_16, 1);

src/proto/fd/tiny_fd.h

@@ -117,6 +117,7 @@ extern "C"
         TINY_FD_FRAME_SUBTYPE_SABM = 0x2C, ///< U-frame subtype SABM
         TINY_FD_FRAME_SUBTYPE_SNRM = 0x80, ///< U-frame subtype SNRM
         TINY_FD_FRAME_SUBTYPE_DISC = 0x40, ///< U-frame subtype DISC
+        TINY_FD_FRAME_SUBTYPE_UI = 0x00, ///< U-frame subtype UI (Unnumbered Information)
     } tiny_fd_frame_subtype_t;
 
     /**
@@ -255,6 +256,13 @@ extern "C"
          */
         uint8_t mode;
 
+        /**
+         * Callback to process incoming UI (Unnumbered Information) frames.
+         * UI frames are connectionless — they can be received in any state (even disconnected).
+         * Can be NULL if UI frames are not needed.
+         */
+        on_frame_read_cb_t on_read_ui_cb;
+
     } tiny_fd_init_t;
 
     /**
@@ -495,6 +503,39 @@ extern "C"
      */
     extern int tiny_fd_send_packet(tiny_fd_handle_t handle, const void *buf, int len, uint32_t timeout);
 
+    /**
+     * @brief Sends UI (Unnumbered Information) frame over full-duplex protocol.
+     *
+     * Sends a connectionless UI frame to the specified address. UI frames can be sent
+     * in any connection state (even when disconnected). They are not acknowledged and
+     * do not use sequence numbers.
+     *
+     * @param handle   tiny_fd_handle_t handle
+     * @param address  address of remote peer. For primary device, please use TINY_FD_PRIMARY_ADDR
+     * @param buf      data to send
+     * @param len      length of data to send
+     *
+     * @return TINY_SUCCESS if the UI frame was queued for sending.
+     *         TINY_ERR_FAILED if no room in internal queue.
+     *         TINY_ERR_DATA_TOO_LARGE if data exceeds MTU.
+     *         TINY_ERR_INVALID_DATA if parameters are invalid.
+     */
+    extern int tiny_fd_send_ui_packet_to(tiny_fd_handle_t handle, uint8_t address, const void *buf, int len);
+
+    /**
+     * @brief Sends UI (Unnumbered Information) frame to primary station.
+     *
+     * Sends a connectionless UI frame to the primary station.
+     * For details, please refer to tiny_fd_send_ui_packet_to().
+     *
+     * @param handle   tiny_fd_handle_t handle
+     * @param buf      data to send
+     * @param len      length of data to send
+     *
+     * @return Success result or error code
+     */
+    extern int tiny_fd_send_ui_packet(tiny_fd_handle_t handle, const void *buf, int len);
+
     /**
      * @}
      */

src/proto/fd/tiny_fd_defines_int.h

@@ -102,6 +102,7 @@ enum
 #define HDLC_U_FRAME_TYPE_SABM 0x2C
 #define HDLC_U_FRAME_TYPE_SNRM 0x80
 #define HDLC_U_FRAME_TYPE_DISC 0x40
+#define HDLC_U_FRAME_TYPE_UI   0x00
 #define HDLC_U_FRAME_TYPE_MASK 0xEC
 
 #define HDLC_P_BIT 0x10

src/proto/fd/tiny_fd_int.h

@@ -105,6 +105,8 @@ extern "C"
         on_frame_read_cb_t on_read_cb;
         /// Callback to process received frames
         on_frame_send_cb_t on_send_cb;
+        /// Callback to process received UI frames
+        on_frame_read_cb_t on_read_ui_cb;
         /// Callback to get connect/disconnect notification
         on_connect_event_cb_t on_connect_event_cb;
         /// Callback to log frames

src/proto/fd/tiny_fd_on_rx_int.h

@@ -142,6 +142,7 @@ static int __on_s_frame_read(tiny_fd_handle_t handle, uint8_t peer, void *data,
                 tiny_frame_header_t frame = {
                     .address = __peer_to_address_field( handle, peer ),
                     .control = HDLC_S_FRAME_BITS | HDLC_S_FRAME_TYPE_RR |
+                        (control & HDLC_P_BIT) |
                         (__i_queue_control_get_next_frame_to_receive(&handle->peers[peer].i_queue_control) << 5),
                 };
                 __put_u_s_frame_to_tx_queue(handle, TINY_FD_QUEUE_S_FRAME, &frame, 2);
@@ -236,6 +237,19 @@ static int __on_u_frame_read(tiny_fd_handle_t handle, uint8_t peer, void *data,
             __switch_to_disconnected_state(handle, peer);
         }
     }
+    else if ( type == HDLC_U_FRAME_TYPE_UI )
+    {
+        // UI (Unnumbered Information) — connectionless data, accepted in any state
+        LOG(TINY_LOG_INFO, "[%p] UI frame received, len=%d\n", handle, len);
+        if ( handle->on_read_ui_cb && len > 2 )
+        {
+            tiny_mutex_unlock(&handle->frames.mutex);
+            handle->on_read_ui_cb(handle->user_data,
+                                   __is_primary_station( handle ) ? (__peer_to_address_field( handle, peer ) >> 2) : TINY_FD_PRIMARY_ADDR,
+                                   (uint8_t *)data + 2, len - 2);
+            tiny_mutex_lock(&handle->frames.mutex);
+        }
+    }
     else
     {
         LOG(TINY_LOG_WRN, "[%p] Unknown hdlc U-frame received\n", handle);

src/proto/fd/tiny_fd_proto_logger.c

@@ -130,6 +130,7 @@ static const char *__get_frame_subtype_str(uint8_t control)
         case HDLC_U_FRAME_TYPE_SABM: return "SABM";
         case HDLC_U_FRAME_TYPE_SNRM: return "SNRM";
         case HDLC_U_FRAME_TYPE_DISC: return "DISC";
+        case HDLC_U_FRAME_TYPE_UI:   return "  UI";
         default:                     return " UNK";
     }
 }

unittest/fd_tests.cpp

@@ -261,9 +261,9 @@ TEST(FD, resend_timeout)
     helper1.send("#");
     std::this_thread::sleep_for(std::chrono::milliseconds(70 * 2 + 100));
     helper1.stop();
-    const uint8_t reconnect_dat[] = {0x7E, 0x01, 0x10, '#',  0x18, 0x1A, 0x7E, // 1-st attempt
-                                     0x7E, 0x01, 0x10, '#',  0x18, 0x1A, 0x7E, // 2-nd attempt (1st retry)
-                                     0x7E, 0x01, 0x10, '#',  0x18, 0x1A, 0x7E, // 3-rd attempt (2nd retry)
+    const uint8_t reconnect_dat[] = {0x7E, 0x01, 0x00, '#',  0x89, 0x8F, 0x7E, // 1-st attempt (I-frame, no P bit in ABM)
+                                     0x7E, 0x01, 0x00, '#',  0x89, 0x8F, 0x7E, // 2-nd attempt (1st retry)
+                                     0x7E, 0x01, 0x00, '#',  0x89, 0x8F, 0x7E, // 3-rd attempt (2nd retry)
                                      0x7E, 0x03, 0x3F, 0x5B, 0xEC, 0x7E};      // Attempt to reconnect (SABM)
     uint8_t buffer[64]{};
     conn.endpoint2().read(buffer, sizeof(buffer));