Use separate method for each property

Author: Arto Kinnunen

features/nanostack/mbed-mesh-api/mbed-mesh-api/MeshInterfaceNanostack.h

@@ -140,8 +140,18 @@ class InterfaceNanostack : public virtual NetworkInterface {
      */
     virtual nsapi_error_t set_file_system_root_path(const char *root_path);
 
-    /** @copydoc NetworkInterface::get_interface_property */
-    virtual nsapi_error_t get_interface_property(nsapi_size_t data_amount, nsapi_size_t *jitter);
+    /** @copydoc NetworkInterface::get_interface_timing_property */
+    virtual nsapi_error_t get_interface_timing_property(unsigned int data_amount,
+                                                        unsigned int *initial_delay_min,
+                                                        unsigned int *initial_delay_max,
+                                                        unsigned int *initial_delay_rand,
+                                                        unsigned int *expected_rtt);
+
+    /** @copydoc NetworkInterface::get_interface_initial_delay */
+    virtual nsapi_error_t get_interface_initial_delay(unsigned int data_amount, unsigned int *initial_delay);
+
+    /** @copydoc NetworkInterface::get_interface_rtt */
+    virtual nsapi_error_t get_interface_rtt(unsigned int *expected_rtt);
 
     /** Get the interface ID
      *  @return  Interface identifier

features/nanostack/mbed-mesh-api/source/MeshInterfaceNanostack.cpp

@@ -19,7 +19,6 @@
 #include "NanostackLockGuard.h"
 #include "mesh_system.h"
 #include "nanostack/net_interface.h"
-#include "nanostack/ns_property.h"
 #include "thread_management_if.h"
 #include "ip6string.h"
 #include "mbed_error.h"
@@ -233,13 +232,55 @@ nsapi_error_t InterfaceNanostack::set_file_system_root_path(const char *root_pat
     return MESH_ERROR_UNKNOWN;
 }
 
-nsapi_error_t InterfaceNanostack::get_interface_property(nsapi_size_t data_amount, nsapi_size_t *jitter) {
-    ns_properties_t ns_properties;
+nsapi_error_t InterfaceNanostack::get_interface_timing_property(unsigned int data_amount,
+                                                                unsigned int *initial_delay_min,
+                                                                unsigned int *initial_delay_max,
+                                                                unsigned int *initial_delay_rand,
+                                                                unsigned int *expected_rtt)
+{
+    net_timing_constraint_t net_timing_constraint;
+
+    if (!initial_delay_min || !initial_delay_max || !initial_delay_rand || !expected_rtt) {
+        return NSAPI_ERROR_PARAMETER;
+    }
+
+    if (arm_nwk_interface_timing_constraint_get(get_interface_id(), data_amount, &net_timing_constraint) == 0) {
+        *initial_delay_min = net_timing_constraint.jitter_min;
+        *initial_delay_max = net_timing_constraint.jitter_max;
+        *initial_delay_rand = net_timing_constraint.jitter_rand;
+        *expected_rtt = net_timing_constraint.network_latency * 2; // RTT = 2 * latency + some processing time
+        return NSAPI_ERROR_OK;
+    }
 
-    ns_properties.data_amount = data_amount;
+    return NSAPI_ERROR_NO_CONNECTION;
+}
+
+nsapi_error_t InterfaceNanostack::get_interface_initial_delay(unsigned int data_amount, unsigned int *initial_delay)
+{
+    net_timing_constraint_t net_timing_constraint;
+
+    if (!initial_delay) {
+        return NSAPI_ERROR_PARAMETER;
+    }
+
+    if (arm_nwk_interface_timing_constraint_get(get_interface_id(), 0, &net_timing_constraint) == 0) {
+        *initial_delay = net_timing_constraint.jitter_rand;
+        return NSAPI_ERROR_OK;
+    }
+
+    return NSAPI_ERROR_NO_CONNECTION;
+}
+
+nsapi_error_t InterfaceNanostack::get_interface_rtt(unsigned int *expected_rtt)
+{
+    net_timing_constraint_t net_timing_constraint;
+
+    if (!expected_rtt) {
+        return NSAPI_ERROR_PARAMETER;
+    }
 
-    if (ns_property_get(get_interface_id(), &ns_properties) == 0) {
-        *jitter = ns_properties.tx_jitter;
+    if (arm_nwk_interface_timing_constraint_get(get_interface_id(), 0, &net_timing_constraint) == 0) {
+        *expected_rtt = net_timing_constraint.network_latency * 2; // RTT = 2 * latency + some processing time
         return NSAPI_ERROR_OK;
     }
 

features/netsocket/NetworkInterface.cpp

@@ -174,7 +174,22 @@ nsapi_error_t NetworkInterface::set_blocking(bool blocking)
     return NSAPI_ERROR_UNSUPPORTED;
 }
 
-nsapi_error_t NetworkInterface::get_interface_property(unsigned int data_amount, unsigned int *jitter)
+nsapi_error_t NetworkInterface::get_interface_timing_property(unsigned int data_amount,
+                                                              unsigned int *initial_delay_min,
+                                                              unsigned int *initial_delay_max,
+                                                              unsigned int *initial_delay_rand,
+                                                              unsigned int *expected_rtt)
+{
+    return NSAPI_ERROR_UNSUPPORTED;
+}
+
+nsapi_error_t NetworkInterface::get_interface_initial_delay(unsigned int data_amount,
+                                                            unsigned int *initial_delay)
+{
+    return NSAPI_ERROR_UNSUPPORTED;
+}
+
+nsapi_error_t NetworkInterface::get_interface_rtt(unsigned int *expected_rtt)
 {
     return NSAPI_ERROR_UNSUPPORTED;
 }

features/netsocket/NetworkInterface.h

@@ -378,14 +378,64 @@ class NetworkInterface: public DNS {
      */
     virtual nsapi_error_t set_blocking(bool blocking);
 
-    /** Get suggested data transmission jitter from underlying network interface.
-     *
-     * @param data_amount Amount of data to be sent
-     * @param jitter Address to location where suggested jitter value is written
-     * @return NSAPI_ERROR_OK on success
-     * @return NSAPI_ERROR_UNSUPPORTED, NSAPI_ERROR_NO_CONNECTION
-     */
-    virtual nsapi_error_t get_interface_property(unsigned int data_amount, unsigned int *jitter);
+    /** Get network interface timing properties.
+     *
+     * Network interfaces have different characteristics. Some wireless networks are
+     * established slowly and may have a high latency while some wired networks are
+     * ready almost instantly after power on.
+     *
+     * Application can use network timing properties to adapt to the varying network
+     * interfaces. Properties include:
+     * * initial delay, a estimated wait time that application should wait after startup before sending data to the network.
+     * * round-trip time, a estimated time between sending a signal and receiving the response.
+     *
+     * @param data_amount Amount of data to be sent in kilobytes.
+     * @param initial_delay_min Address to minimum delay value (ms), must be non-null.
+     * @param initial_delay_max Address to maximum delay value (ms), must be non-null.
+     * @param initial_delay_rand Address to randomized delay value (ms), must be non-null.
+     * @param expected_rtt Address to expected round-trip time value (ms), must be non-null.
+     * @return NSAPI_ERROR_OK on success.
+     * @return NSAPI_ERROR_UNSUPPORTED if API is not implemented to interface.
+     * @return NSAPI_ERROR_NO_CONNECTION if network is not connected.
+     * @return NSAPI_ERROR_PARAMETER. if input parameters are not valid.
+     */
+    virtual nsapi_error_t get_interface_timing_property(unsigned int data_amount,
+                                                        unsigned int *initial_delay_min,
+                                                        unsigned int *initial_delay_max,
+                                                        unsigned int *initial_delay_rand,
+                                                        unsigned int *expected_rtt);
+
+    /** Get initial delay for the network interface
+     *
+     * Initial delay can be used to optimize network performance. Some wireless networks
+     * use a lot of network bandwidth to find and extend the network during startup.
+     * Having an application sending data aggressively during the startup can result to
+     * network congestion that will drop network performance even more.
+     * Initial delay is a randomized value based on the selected interface properties.
+     *
+     * @param data_amount Amount of data in kilobytes that application is going to send.
+     * @param initial_delay Address to location where initial_delay is written in milliseconds.
+     * @return NSAPI_ERROR_OK on success.
+     * @return NSAPI_ERROR_UNSUPPORTED if API is not implemented to interface.
+     * @return NSAPI_ERROR_NO_CONNECTION if network is not connected.
+     * @return NSAPI_ERROR_PARAMETER. if input parameters are not valid.
+     */
+    virtual nsapi_error_t get_interface_initial_delay(unsigned int data_amount,
+                                                      unsigned int *initial_delay);
+
+    /** Get network interface expected round-trip time (RTT)
+     *
+     * Application can use expected RTT to adjust possible retry intervals.
+     * Wired networks may have RTT value less than a seconds while some wireless
+     * networks could have a RTT up to several minutes.
+     *
+     * @param expected_rtt Address to location where expected RTT is written (ms).
+     * @return NSAPI_ERROR_OK on success.
+     * @return NSAPI_ERROR_UNSUPPORTED if API is not implemented to interface.
+     * @return NSAPI_ERROR_NO_CONNECTION if network is not connected.
+     * @return NSAPI_ERROR_PARAMETER. if input parameters are not valid.
+     */
+    virtual nsapi_error_t get_interface_rtt(unsigned int *expected_rtt);
 
     /** Return pointer to an EthInterface.
      * @return Pointer to requested interface type or NULL if this class doesn't implement the interface.