Added couple NRM tests

Author: lexus2k

Makefile.cpputest

@@ -18,7 +18,8 @@ OBJ_UNIT_TEST = \
         unittest/packet_tests.o \
         unittest/hdlc_tests.o \
         unittest/light_tests.o \
-        unittest/tiny_fd_tests.o \
+        unittest/tiny_fd_abm_tests.o \
+        unittest/tiny_fd_nrm_tests.o \
         unittest/fd_tests.o \
         unittest/fd_multidrop_tests.o \
 

src/hal/tiny_debug.c

@@ -48,7 +48,7 @@ static FILE *get_log_file(uintptr_t id)
             return NULL;
         }
         // Num# - is frame number, Exp# - is expected frame number from remote peer
-        fprintf(log_file, " time ms, DIR, FR, Type, Num#, Exp#\n");
+        fprintf(log_file, " time ms, DIR, ADDR, FR, Type, Num#, Exp#\n");
     }
     return log_file;
 }

src/proto/fd/tiny_fd.c

@@ -46,26 +46,6 @@ static void on_frame_send(void *user_data, const uint8_t *data, int len);
 // Helper functions
 ///////////////////////////////////////////////////////////////////////////////
 
-static uint8_t __switch_to_next_peer(tiny_fd_handle_t handle)
-{
-    const uint8_t start_peer = handle->next_peer;
-    do
-    {
-        if ( ++handle->next_peer >= handle->peers_count )
-        {
-            handle->next_peer = 0;
-        }
-        if ( handle->peers[ handle->next_peer ].addr != HDLC_INVALID_PEER_INDEX )
-        {
-            break;
-        }
-    } while ( start_peer != handle->next_peer );
-    LOG(TINY_LOG_INFO, "[%p] Switching to peer [%02X]\n", handle, handle->next_peer);
-    return start_peer != handle->next_peer;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
 #if 0
 static inline uint8_t __number_of_awaiting_tx_i_frames(tiny_fd_handle_t handle, uint8_t peer)
 {
@@ -208,15 +188,24 @@ static void on_frame_read(void *user_data, uint8_t *data, int len)
     {
         LOG(TINY_LOG_WRN, "[%p] Unknown hdlc frame received\n", handle);
     }
-    if ( control & HDLC_P_BIT )
+    // Check that if we are in NRM mode then we have something to send
+    if ( handle->mode == TINY_FD_MODE_NRM )
     {
-        // Check that if we are in NRM mode then we have something to send
-        if ( handle->mode == TINY_FD_MODE_NRM )
+        if ( control & ( HDLC_P_BIT | HDLC_F_BIT ) )
         {
             LOG(TINY_LOG_INFO, "[%p] [CAPTURED MARKER]\n", handle);
+            // Cool! Now we have marker again, and we can send
+            tiny_events_set( &handle->events, FD_EVENT_HAS_MARKER );
+            // For primary station
+            //    1. Switch to the next peer
+            //    2. If no I-frames to send, then put RR S-frame to the queue with poll bit set
+            //    3. If I-frames to send, then send I-frames (1 or multiple)
+            //       3.1. The last one should have final bit set
+            // For secondary station
+            //    1. If no I-frames to send, then put RR S-frame to the queue with poll bit set
+            //    2. If I-frames to send, then send I-frames (1 or multiple)
+            //       2.1. The last one should have final bit set
         }
-        // Cool! Now we have marker again, and we can send
-        tiny_events_set( &handle->events, FD_EVENT_HAS_MARKER );
     }
     tiny_mutex_unlock(&handle->frames.mutex);
 }
@@ -247,23 +236,28 @@ static void on_frame_send(void *user_data, const uint8_t *data, int len)
         tiny_fd_queue_free_by_header( &handle->frames.s_queue, data );
     }
     // Clear send flag and clear marker if final was transferred. For ABM mode the marker is never cleared
-    uint8_t flags = FD_EVENT_TX_SENDING;
-    if ( (control & HDLC_F_BIT) && handle->mode == TINY_FD_MODE_NRM )
+    uint8_t flags_to_clear = FD_EVENT_TX_SENDING;
+    if ( handle->mode == TINY_FD_MODE_NRM )
     {
         // Let's talk to the next station if we are primary
         // Of course, we could switch to the next peer upon receving response
         // from the peer we provided the marker to... But what? What if
         // remote peer never responds to us. So, having switch procedure
         // in this callback simplifies things
-        if ( __is_primary_station( handle ) )
+        if ( __is_primary_station( handle ) && (control & HDLC_P_BIT) )
         {
             __switch_to_next_peer( handle );
+            LOG(TINY_LOG_INFO, "[%p] [RELEASED MARKER]\n", handle);
+            flags_to_clear |= FD_EVENT_HAS_MARKER;
+        }
+        else if ( !__is_primary_station( handle ) && (control & HDLC_F_BIT) )
+        {
+            LOG(TINY_LOG_INFO, "[%p] [RELEASED MARKER]\n", handle);
+            flags_to_clear |= FD_EVENT_HAS_MARKER;
         }
-        LOG(TINY_LOG_INFO, "[%p] [RELEASED MARKER]\n", handle);
-        flags |= FD_EVENT_HAS_MARKER;
     }
-    tiny_events_clear( &handle->events, flags );
-    tiny_mutex_unlock(&handle->frames.mutex);
+    tiny_events_clear( &handle->events, flags_to_clear );
+    tiny_mutex_unlock( &handle->frames.mutex );
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -421,6 +415,7 @@ int tiny_fd_init(tiny_fd_handle_t *handle, tiny_fd_init_t *init)
 
     tiny_mutex_create(&protocol->frames.mutex);
     tiny_events_create(&protocol->events);
+    // Primary station has marker by default
     tiny_events_set( &protocol->events, FD_EVENT_QUEUE_HAS_FREE_SLOTS |
                                         (__is_primary_station( protocol ) ? FD_EVENT_HAS_MARKER : 0) );
     *handle = protocol;
@@ -629,7 +624,12 @@ static void tiny_fd_disconnected_check_idle_timeout(tiny_fd_handle_t handle, uin
 
 int tiny_fd_get_tx_data(tiny_fd_handle_t handle, void *data, int len, uint32_t timeout)
 {
+    // TODO: !!!!!
+    // We cannot generate data forever, and we should return result as soon as possible
+    // Now this is not true for NRM mode, as we can generate data forever until 
+    // passed buffer is filled up.
     bool repeat = true;
+    bool wait_point_passed = false;
     int result = 0;
     // TODO: Check for correct mutex usage here. Some fields are not protected
     const uint8_t peer = handle->next_peer;
@@ -656,6 +656,11 @@ int tiny_fd_get_tx_data(tiny_fd_handle_t handle, void *data, int len, uint32_t t
             {
                 tiny_fd_disconnected_check_idle_timeout(handle, peer);
             }
+            // TODO: This point cannot be reached twice!!!!
+            if (wait_point_passed) {
+                break;
+            }
+            wait_point_passed = true;
             // Since no send operation is in progress, check if we have something to send
             // Check if the station has marker to send FIRST (That means, we are allowed to send anything still)
             if ( tiny_events_wait(&handle->events, FD_EVENT_HAS_MARKER, EVENT_BITS_LEAVE, timeout ) )
@@ -689,7 +694,7 @@ int tiny_fd_get_tx_data(tiny_fd_handle_t handle, void *data, int len, uint32_t t
             {
                 if ( __time_passed_since_last_marker_seen(handle) >= handle->retry_timeout )
                 {
-                    // Return marker back as remote station not responding
+                    // Return marker back to primary station as remote station not responding
                     LOG(TINY_LOG_CRIT, "[%p] RETURN MARKER BACK\n", handle );
                     tiny_events_set( &handle->events, FD_EVENT_HAS_MARKER );
                 }
@@ -699,7 +704,9 @@ int tiny_fd_get_tx_data(tiny_fd_handle_t handle, void *data, int len, uint32_t t
                 }
             }
         }
-        result += generated_data;
+        if (result >= 0) {
+            result += generated_data;
+        }
         if ( !generated_data )
         {
             if ( !repeat )
@@ -964,6 +971,7 @@ int tiny_fd_register_peer(tiny_fd_handle_t handle, uint8_t address)
     tiny_mutex_lock(&handle->frames.mutex);
     if ( __address_field_to_peer( handle, address ) != HDLC_INVALID_PEER_INDEX )
     {
+        // Peer already registered
         tiny_mutex_unlock(&handle->frames.mutex);
         return TINY_ERR_FAILED;
     }

src/proto/fd/tiny_fd_defines_int.h

@@ -38,22 +38,47 @@
 #define LOG(lvl, fmt, ...) TINY_LOG(lvl, fmt, ##__VA_ARGS__)
 // id - unique id of the protocol instance
 // direction - direction of the log, can be "OUT" or "IN"
+// addr - address of the peer, can be primary or secondary station address
 // frame type - 'S', 'I' or 'U'
 // subtype - subtype of the frame, can be "RR", "REJ", "UA", etc.
 // ns - N(S) sequence number, nr - N(R) sequence number
-#define FILE_LOG(id, direction, frame, subtype, ns, nr) \
-                TINY_FILE_LOG(id, "%s,  %c, %s,    %d,   %d\n", direction, frame, subtype, ns, nr)
+#define FILE_LOG(id, direction, addr, frame, subtype, ns, nr) \
+                TINY_FILE_LOG(id, "%s,   %02X,  %c, %s,    %d,   %d\n", direction, addr, frame, subtype, ns, nr)
 #else
 #define LOG(...)
 #define FILE_LOG(...)
 #endif
 
 enum
 {
+    /**
+     * FD_EVENT_TX_SENDING indicates that currently frame is being sent.
+     * Higer layer will not try to send new frames until this event is cleared.
+     */
     FD_EVENT_TX_SENDING = 0x01,            // Global event
+
+    /**
+     * FD_EVENT_TX_DATA_AVAILABLE indicates that there is data available for transmission.
+     * This event is set when there is data in the TX queue.
+     */
     FD_EVENT_TX_DATA_AVAILABLE = 0x02,     // Global event
+
+    /**
+     * FD_EVENT_QUEUE_HAS_FREE_SLOTS indicates that there are free slots in the TX queue.
+     * This event is set when there is at least one free slot in the TX queue.
+     * It is used to notify higher layers that they can send more data.
+     */
     FD_EVENT_QUEUE_HAS_FREE_SLOTS = 0x04,  // Global event
+
+    /**
+     * FD_EVENT_CAN_ACCEPT_I_FRAMES indicates that the protocol can accept new I-frames for sending.
+     * This event is set when the protocol is ready to accept new I-frames.
+     */
     FD_EVENT_CAN_ACCEPT_I_FRAMES = 0x08,   // Local event
+
+    /**
+     * 
+     */
     FD_EVENT_HAS_MARKER          = 0x10,   // Global event
 };
 

src/proto/fd/tiny_fd_peers_int.h

@@ -89,3 +89,26 @@ static uint8_t __peer_to_address_field(tiny_fd_handle_t handle, uint8_t peer)
 {
     return handle->peers[peer].addr & (~HDLC_CR_BIT);
 }
+
+///////////////////////////////////////////////////////////////////////////////
+
+static uint8_t __switch_to_next_peer(tiny_fd_handle_t handle)
+{
+    const uint8_t start_peer = handle->next_peer;
+    do
+    {
+        if ( ++handle->next_peer >= handle->peers_count )
+        {
+            handle->next_peer = 0;
+        }
+        if ( handle->peers[ handle->next_peer ].addr != HDLC_INVALID_PEER_INDEX )
+        {
+            break;
+        }
+    } while ( start_peer != handle->next_peer );
+    LOG(TINY_LOG_INFO, "[%p] Switching to peer [%02X]\n", handle, handle->next_peer);
+    return start_peer != handle->next_peer;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+

src/proto/fd/tiny_fd_proto_logger.c

@@ -153,6 +153,7 @@ void __tiny_fd_log_frame(tiny_fd_handle_t handle,
     }
     FILE_LOG((uintptr_t)handle,
         direction == TINY_FD_FRAME_DIRECTION_IN ? " IN" : "OUT",
+        data[0],
         __get_frame_type_str(data[1]),
         __get_frame_subtype_str(data[1]),
         __get_frame_sequence(data[1]),