Merge pull request #13046 from hugueskamba/hk_use_chrono

Use std::chrono based functions

Author: 0xc0170

TESTS/netsocket/udp/main.cpp

@@ -118,9 +118,9 @@ void fill_tx_buffer_ascii(char *buff, size_t len)
     }
 }
 
-int split2half_rmng_udp_test_time()
+microseconds split2half_rmng_udp_test_time()
 {
-    return (udp_global::TESTS_TIMEOUT - tc_bucket.read()) / 2;
+    return (udp_global::TESTS_TIMEOUT - tc_bucket.elapsed_time()) / 2;
 }
 
 #if MBED_CONF_NSAPI_SOCKET_STATS_ENABLED
@@ -133,7 +133,7 @@ int fetch_stats()
 // Test setup
 utest::v1::status_t greentea_setup(const size_t number_of_cases)
 {
-    GREENTEA_SETUP(udp_global::TESTS_TIMEOUT, "default_auto");
+    GREENTEA_SETUP(seconds(udp_global::TESTS_TIMEOUT).count(), "default_auto");
     _ifup();
     tc_bucket.start();
     return greentea_test_setup_handler(number_of_cases);

TESTS/netsocket/udp/udp_tests.h

@@ -21,6 +21,8 @@
 #include "../test_params.h"
 #include "mbed_trace.h"
 
+using namespace std::chrono;
+
 #define TRACE_GROUP "GRNT"
 
 NetworkInterface *get_interface();
@@ -37,18 +39,18 @@ int fetch_stats(void);
 /**
  * Single testcase might take only half of the remaining execution time
  */
-int split2half_rmng_udp_test_time(); // [s]
+microseconds split2half_rmng_udp_test_time();
 
 namespace udp_global {
 #ifdef MBED_GREENTEA_TEST_UDPSOCKET_TIMEOUT_S
-static const int TESTS_TIMEOUT = MBED_GREENTEA_TEST_UDPSOCKET_TIMEOUT_S;
+static constexpr seconds TESTS_TIMEOUT(MBED_GREENTEA_TEST_UDPSOCKET_TIMEOUT_S);
 #else
 #define MESH 3
 #define WISUN 0x2345
 #if MBED_CONF_TARGET_NETWORK_DEFAULT_INTERFACE_TYPE == MESH && MBED_CONF_NSAPI_DEFAULT_MESH_TYPE == WISUN
-static const int TESTS_TIMEOUT = (25 * 60);
+static constexpr seconds TESTS_TIMEOUT = 25min;
 #else
-static const int TESTS_TIMEOUT = (20 * 60);
+static constexpr seconds TESTS_TIMEOUT = 20min;
 #endif
 #endif
 

TESTS/netsocket/udp/udpsocket_echotest.cpp

@@ -23,13 +23,14 @@
 #include "utest.h"
 #include "udp_tests.h"
 
+using namespace std::chrono;
 using namespace utest::v1;
 
 namespace {
 static const int SIGNAL_SIGIO_RX = 0x1;
 static const int SIGNAL_SIGIO_TX = 0x2;
-static const int SIGIO_TIMEOUT = 5000; //[ms]
-static const int SOCKET_TIMEOUT = (10 * 1000); //[ms]
+static constexpr seconds SIGIO_TIMEOUT = 5s;
+static constexpr seconds SOCKET_TIMEOUT = 10s;
 static const int RETRIES = 2;
 
 static const double EXPECTED_LOSS_RATIO = 0.0;
@@ -53,7 +54,7 @@ static bool pkt_received[PKTS] = {false, false, false, false, false, false, fals
                                  };
 
 Timer tc_exec_time;
-int time_allotted;
+microseconds time_allotted;
 }
 
 static void _sigio_handler()
@@ -75,7 +76,7 @@ void UDPSOCKET_ECHOTEST_impl(bool use_sendto)
         TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, sock.connect(udp_addr));
     }
 
-    sock.set_timeout(SOCKET_TIMEOUT);
+    sock.set_timeout(milliseconds(SOCKET_TIMEOUT).count());
     int recvd;
     int sent;
     int packets_sent = 0;
@@ -169,7 +170,7 @@ void UDPSOCKET_ECHOTEST_CONNECT_SEND_RECV()
 void UDPSOCKET_ECHOTEST_NONBLOCK_impl(bool use_sendto)
 {
     tc_exec_time.start();
-    time_allotted = split2half_rmng_udp_test_time(); // [s]
+    time_allotted = split2half_rmng_udp_test_time();
 
     SocketAddress udp_addr;
     NetworkInterface::get_default_instance()->gethostbyname(ECHO_SERVER_ADDR, &udp_addr);
@@ -211,8 +212,12 @@ void UDPSOCKET_ECHOTEST_NONBLOCK_impl(bool use_sendto)
             } else if (sent == pkt_s) {
                 packets_sent++;
             } else if (sent == NSAPI_ERROR_WOULD_BLOCK) {
-                if (tc_exec_time.read() >= time_allotted ||
-                        signals.wait_all(SIGNAL_SIGIO_TX, SIGIO_TIMEOUT) == osFlagsErrorTimeout) {
+                if (
+                    (tc_exec_time.elapsed_time() >= time_allotted)
+                    || signals.wait_all(
+                        SIGNAL_SIGIO_TX, milliseconds(SIGIO_TIMEOUT).count()
+                    ) == osFlagsErrorTimeout
+                ) {
                     continue;
                 }
                 --retry_cnt;
@@ -230,10 +235,13 @@ void UDPSOCKET_ECHOTEST_NONBLOCK_impl(bool use_sendto)
                 }
 
                 if (recvd == NSAPI_ERROR_WOULD_BLOCK) {
-                    if (tc_exec_time.read() >= time_allotted) {
+                    if (tc_exec_time.elapsed_time() >= time_allotted) {
                         break;
                     }
-                    signals.wait_all(SIGNAL_SIGIO_RX, SIGIO_TIMEOUT);
+                    signals.wait_all(
+                        SIGNAL_SIGIO_RX,
+                        milliseconds(SIGIO_TIMEOUT).count()
+                    );
                     --retry_recv;
                     continue;
                 } else if (recvd < 0) {

components/802.15.4_RF/atmel-rf-driver/source/NanostackRfPhyAtmel.cpp

@@ -35,6 +35,8 @@
 #include "Timeout.h"
 #include "platform/mbed_error.h"
 
+using namespace std::chrono;
+
 #define TRACE_GROUP "AtRF"
 
 /*Worst case sensitivity*/
@@ -356,9 +358,9 @@ static rf_trx_part_e rf_radio_type_read(void)
 static void rf_if_ack_wait_timer_start(uint16_t slots)
 {
 #ifdef MBED_CONF_RTOS_PRESENT
-    rf->ack_timer.attach_us(rf_if_ack_timer_signal, slots * 50);
+    rf->ack_timer.attach(rf_if_ack_timer_signal, slots * 50us);
 #else
-    rf->ack_timer.attach_us(rf_ack_wait_timer_interrupt, slots * 50);
+    rf->ack_timer.attach(rf_ack_wait_timer_interrupt, slots * 50us);
 #endif
 }
 
@@ -372,9 +374,9 @@ static void rf_if_ack_wait_timer_start(uint16_t slots)
 static void rf_if_calibration_timer_start(uint32_t slots)
 {
 #ifdef MBED_CONF_RTOS_PRESENT
-    rf->cal_timer.attach_us(rf_if_cal_timer_signal, slots * 50);
+    rf->cal_timer.attach(rf_if_cal_timer_signal, slots * 50us);
 #else
-    rf->cal_timer.attach_us(rf_calibration_timer_interrupt, slots * 50);
+    rf->cal_timer.attach(rf_calibration_timer_interrupt, slots * 50us);
 #endif
 }
 
@@ -388,9 +390,9 @@ static void rf_if_calibration_timer_start(uint32_t slots)
 static void rf_if_cca_timer_start(uint32_t slots)
 {
 #ifdef MBED_CONF_RTOS_PRESENT
-    rf->cca_timer.attach_us(rf_if_cca_timer_signal, slots * 50);
+    rf->cca_timer.attach(rf_if_cca_timer_signal, slots * 50us);
 #else
-    rf->cca_timer.attach_us(rf_cca_timer_interrupt, slots * 50);
+    rf->cca_timer.attach(rf_cca_timer_interrupt, slots * 50us);
 #endif
 }
 
@@ -519,14 +521,14 @@ static void rf_if_reset_radio(void)
 #endif
     rf->IRQ.rise(nullptr);
     rf->RST = 1;
-    ThisThread::sleep_for(2);
+    ThisThread::sleep_for(2ms);
     rf->RST = 0;
-    ThisThread::sleep_for(10);
+    ThisThread::sleep_for(10ms);
     CS_RELEASE();
     rf->SLP_TR = 0;
-    ThisThread::sleep_for(10);
+    ThisThread::sleep_for(10ms);
     rf->RST = 1;
-    ThisThread::sleep_for(10);
+    ThisThread::sleep_for(10ms);
 
     rf->IRQ.rise(&rf_if_interrupt_handler);
 }

components/802.15.4_RF/stm-s2lp-rf-driver/source/NanostackRfPhys2lp.cpp

@@ -15,6 +15,7 @@
  */
 #include <string.h>
 #if defined(MBED_CONF_NANOSTACK_CONFIGURATION) && DEVICE_SPI && DEVICE_INTERRUPTIN && defined(MBED_CONF_RTOS_PRESENT)
+
 #include "platform/arm_hal_interrupt.h"
 #include "nanostack/platform/arm_hal_phy.h"
 #include "ns_types.h"
@@ -31,6 +32,7 @@
 #include "mbed_wait_api.h"
 #include "platform/mbed_error.h"
 
+using namespace std::chrono;
 using namespace mbed;
 using namespace rtos;
 
@@ -276,7 +278,7 @@ static void rf_calculate_symbol_rate(uint32_t baudrate, phy_modulation_e modulat
 
 static uint32_t rf_get_timestamp(void)
 {
-    return (uint32_t)rf->tx_timer.read_us();
+    return (uint32_t)rf->tx_timer.elapsed_time().count();
 }
 
 static void rf_update_tx_active_time(void)
@@ -866,7 +868,7 @@ static void rf_cca_timer_stop(void)
 
 static void rf_cca_timer_start(uint32_t slots)
 {
-    rf->cca_timer.attach_us(rf_cca_timer_signal, slots);
+    rf->cca_timer.attach(rf_cca_timer_signal, microseconds(slots));
     TEST_CSMA_STARTED
 }
 
@@ -903,7 +905,7 @@ static void rf_backup_timer_stop(void)
 
 static void rf_backup_timer_start(uint32_t slots)
 {
-    rf->backup_timer.attach_us(rf_backup_timer_signal, slots);
+    rf->backup_timer.attach(rf_backup_timer_signal, microseconds(slots));
 }
 
 static int8_t rf_start_cca(uint8_t *data_ptr, uint16_t data_length, uint8_t tx_handle, data_protocol_e data_protocol)
@@ -1177,10 +1179,10 @@ static void rf_reset(void)
 {
     // Shutdown
     rf->SDN = 1;
-    ThisThread::sleep_for(10);
+    ThisThread::sleep_for(10ms);
     // Wake up
     rf->SDN = 0;
-    ThisThread::sleep_for(10);
+    ThisThread::sleep_for(10ms);
 }
 
 static void rf_init(void)

components/storage/blockdevice/COMPONENT_QSPIF/QSPIFBlockDevice.cpp

@@ -28,6 +28,7 @@
 #include "mbed_trace.h"
 #define TRACE_GROUP "QSPIF"
 
+using namespace std::chrono;
 using namespace mbed;
 
 /* Default QSPIF Parameters */
@@ -1228,7 +1229,7 @@ bool QSPIFBlockDevice::_is_mem_ready()
     bool mem_ready = true;
 
     do {
-        rtos::ThisThread::sleep_for(1);
+        rtos::ThisThread::sleep_for(1ms);
         retries++;
         //Read Status Register 1 from device
         if (QSPI_STATUS_OK != _qspi_send_general_command(QSPIF_INST_RSR1, QSPI_NO_ADDRESS_COMMAND,

features/FEATURE_BLE/ble/common/Duration.h

@@ -20,6 +20,7 @@
 #include <stdint.h>
 #include <stddef.h>
 #include "platform/mbed_assert.h"
+#include "platform/mbed_chrono.h"
 
 namespace ble {
 
@@ -231,6 +232,48 @@ struct Duration {
         return Duration(Forever::VALUE);
     }
 
+#if defined(DOXYGEN_ONLY)
+    /**
+     * Test if the forever value is being held
+     * @return True if the forever value is held False otherwise
+     */
+    bool isForever() const;
+#else
+    // Overload when Forever isn't defined
+    template<typename DefaultForever = void*>
+    std::enable_if_t<
+        std::is_same<DefaultForever, Forever>::value,
+        bool
+    >
+    isForever() const
+    {
+        return false;
+    }
+
+    // Overload when Forever is defined
+    template<typename DefaultForever = void*>
+    std::enable_if_t<
+        !std::is_same<DefaultForever, Forever>::value,
+        bool
+    >
+    isForever() const
+    {
+        return duration == Forever::VALUE;
+    }
+#endif
+
+    /**
+     * Convert the duration into an std::chrono one.
+     * @return The duration in the std::chrono format.
+     */
+    std::chrono::duration<Rep, typename std::ratio<TB, 1000000>::type>
+    valueChrono() const
+    {
+        MBED_ASSERT(!isForever());
+
+        return std::chrono::duration<Rep, typename std::ratio<TB, 1000000>::type>{duration};
+    }
+
 private:
     static Rep clamp(Rep in)
     {

features/FEATURE_BLE/source/generic/GenericGap.tpp

@@ -27,6 +27,8 @@
 
 #include "drivers/Timeout.h"
 
+using namespace std::chrono;
+
 namespace ble {
 namespace generic {
 
@@ -1390,9 +1392,9 @@ void GenericGap<PalGapImpl, PalSecurityManager, ConnectionEventMonitorEventHandl
         update_random_address();
 
         // Schedule rotations every 15 minutes as recomended by the spec
-        _address_rotation_ticker.attach_us(
+        _address_rotation_ticker.attach(
             mbed::callback(this, &GenericGap::on_address_rotation_timeout),
-            15 * 60 * 1000000U
+            15min
         );
     } else {
         // Stop ticker
@@ -1917,9 +1919,9 @@ ble_error_t GenericGap<PalGapImpl, PalSecurityManager, ConnectionEventMonitorEve
 
         _advertising_timeout.detach();
         if (maxDuration.value()) {
-            _advertising_timeout.attach_us(
+            _advertising_timeout.attach(
                 mbed::callback(this, &GenericGap::on_advertising_timeout),
-                durationCast<millisecond_t>(maxDuration).value()
+                maxDuration.valueChrono()
             );
         }
     }
@@ -2500,9 +2502,9 @@ ble_error_t GenericGap<PalGapImpl, PalSecurityManager, ConnectionEventMonitorEve
 
         _scan_timeout.detach();
         if (duration.value()) {
-            _scan_timeout.attach_us(
+            _scan_timeout.attach(
                 mbed::callback(this, &GenericGap::on_scan_timeout_),
-                microsecond_t(duration).value()
+                duration.valueChrono()
             );
         }
     }