Cellular: Convert to Chrono

Note that documentation for random_max_start_delay config setting has
been changed to indicate that the setting is in seconds, and always has
been. No functional change.

Author: kjbracey

features/cellular/framework/API/ATHandler.h

@@ -19,11 +19,13 @@
 #define AT_HANDLER_H_
 
 #include "platform/mbed_retarget.h"
+#include "platform/mbed_chrono.h"
 
 #include "events/EventQueue.h"
 #include "nsapi_types.h"
 
 #include "Callback.h"
+#include "rtos/Kernel.h"
 
 #include <cstdarg>
 
@@ -78,6 +80,16 @@ class ATHandler {
      */
     ATHandler(FileHandle *fh, events::EventQueue &queue, uint32_t timeout, const char *output_delimiter, uint16_t send_delay = 0);
 
+    /** Constructor
+     *
+     *  @param fh               file handle used for reading AT responses and writing AT commands
+     *  @param queue            Event queue used to transfer sigio events to this thread
+     *  @param timeout          Timeout when reading for AT response
+     *  @param output_delimiter delimiter used when parsing at responses, "\r" should be used as output_delimiter
+     *  @param send_delay       the minimum delay in ms between the end of last response and the beginning of a new command
+     */
+    ATHandler(FileHandle *fh, events::EventQueue &queue, mbed::chrono::milliseconds_u32 timeout, const char *output_delimiter, std::chrono::duration<uint16_t, std::milli> send_delay = std::chrono::milliseconds(0));
+
     ~ATHandler();
 
     /** Return used file handle.
@@ -126,6 +138,13 @@ class ATHandler {
      */
     void set_at_timeout(uint32_t timeout_milliseconds, bool default_timeout = false);
 
+    /** Set timeout in milliseconds for AT commands
+     *
+     *  @param timeout               Timeout in milliseconds
+     *  @param default_timeout       Store as default timeout
+     */
+    void set_at_timeout(mbed::chrono::milliseconds_u32 timeout, bool default_timeout = false);
+
     /** Restore timeout to previous timeout. Handy if there is a need to change timeout temporarily.
      */
     void restore_at_timeout();
@@ -157,6 +176,13 @@ class ATHandler {
      */
     bool sync(int timeout_ms);
 
+    /** Synchronize AT command and response handling to modem.
+     *
+     *  @param timeout ATHandler timeout when trying to sync. Will be restored when function returns.
+     *  @return true is synchronization was successful, false in case of failure
+     */
+    bool sync(std::chrono::duration<int, std::milli> timeout);
+
     /** Sets the delay to be applied before sending any AT command.
      *
      *  @param send_delay the minimum delay in ms between the end of last response and the beginning of a new command
@@ -565,11 +591,11 @@ class ATHandler {
     char *_output_delimiter;
 
     oob_t *_oobs;
-    uint32_t _at_timeout;
-    uint32_t _previous_at_timeout;
+    mbed::chrono::milliseconds_u32 _at_timeout;
+    mbed::chrono::milliseconds_u32 _previous_at_timeout;
 
-    uint16_t _at_send_delay;
-    uint64_t _last_response_stop;
+    std::chrono::duration<uint16_t, std::milli> _at_send_delay;
+    rtos::Kernel::Clock::time_point _last_response_stop;
 
     int32_t _ref_count;
     bool _is_fh_usable;
@@ -610,7 +636,7 @@ class ATHandler {
     bool _use_delimiter;
 
     // time when a command or an URC processing was started
-    uint64_t _start_time;
+    rtos::Kernel::Clock::time_point _start_time;
     // eventqueue event id
     int _event_id;
 

features/cellular/framework/AT/AT_CellularContext.cpp

@@ -27,13 +27,13 @@
 #endif // #if DEVICE_SERIAL
 #include "ThisThread.h"
 
-#define NETWORK_TIMEOUT 30 * 60 * 1000 // 30 minutes
-#define DEVICE_TIMEOUT 5 * 60 * 1000 // 5 minutes
+#define NETWORK_TIMEOUT 30min
+#define DEVICE_TIMEOUT 5min
 // Timeout to wait for URC indicating ciot optimization support from network
-#define CP_OPT_NW_REPLY_TIMEOUT 3000 // 3 seconds
+#define CP_OPT_NW_REPLY_TIMEOUT 3s
 
 #if NSAPI_PPP_AVAILABLE
-#define AT_SYNC_TIMEOUT 1000 // 1 second timeout
+#define AT_SYNC_TIMEOUT 1s
 #include "nsapi_ppp.h"
 #endif
 
@@ -45,6 +45,7 @@
 using namespace mbed_cellular_util;
 using namespace mbed;
 using namespace rtos;
+using namespace std::chrono_literals;
 
 AT_CellularContext::AT_CellularContext(ATHandler &at, CellularDevice *device, const char *apn, bool cp_req, bool nonip_req) :
     _current_op(OP_INVALID), _dcd_pin(NC), _active_high(false), _cp_req(cp_req), _is_connected(false), _at(at)
@@ -118,7 +119,7 @@ nsapi_error_t AT_CellularContext::connect()
     } else {
         if (_cb_data.error == NSAPI_ERROR_ALREADY) {
             // device is already attached, to be async we must use queue to connect and give proper callbacks
-            int id = _device->get_queue()->call_in(0, this, &AT_CellularContext::do_connect_with_retry);
+            int id = _device->get_queue()->call(this, &AT_CellularContext::do_connect_with_retry);
             if (id == 0) {
                 return NSAPI_ERROR_NO_MEMORY;
             }
@@ -162,7 +163,8 @@ nsapi_error_t AT_CellularContext::check_operation(nsapi_error_t err, ContextOper
     _current_op = op;
     if (err == NSAPI_ERROR_IN_PROGRESS || err == NSAPI_ERROR_OK) {
         if (_is_blocking) {
-            int sema_acq = _semaphore.try_acquire_for(get_timeout_for_operation(op)); // cellular network searching may take several minutes
+            auto d = std::chrono::duration<uint32_t, std::milli>(get_timeout_for_operation(op));
+            int sema_acq = _semaphore.try_acquire_for(d); // cellular network searching may take several minutes
             if (!sema_acq) {
                 tr_warning("No cellular connection");
                 return NSAPI_ERROR_TIMEOUT;
@@ -181,11 +183,11 @@ nsapi_connection_status_t AT_CellularContext::get_connection_status() const
 
 uint32_t AT_CellularContext::get_timeout_for_operation(ContextOperation op) const
 {
-    uint32_t timeout = NETWORK_TIMEOUT; // default timeout is 30 minutes as registration and attach may take time
+    std::chrono::duration<uint32_t, std::milli> timeout = NETWORK_TIMEOUT; // default timeout is 30 minutes as registration and attach may take time
     if (op == OP_SIM_READY || op == OP_DEVICE_READY) {
         timeout = DEVICE_TIMEOUT; // use 5 minutes for device ready and sim
     }
-    return timeout;
+    return timeout.count();
 }
 
 bool AT_CellularContext::is_connected()
@@ -716,7 +718,7 @@ nsapi_error_t AT_CellularContext::disconnect()
         do_disconnect();
         return _cb_data.error;
     } else {
-        int event_id = _device->get_queue()->call_in(0, this, &AT_CellularContext::do_disconnect);
+        int event_id = _device->get_queue()->call(this, &AT_CellularContext::do_disconnect);
         if (event_id == 0) {
             return NSAPI_ERROR_NO_MEMORY;
         }
@@ -742,7 +744,7 @@ void AT_CellularContext::deactivate_context()
 void AT_CellularContext::check_and_deactivate_context()
 {
     // CGACT and CGATT commands might take up to 3 minutes to respond.
-    _at.set_at_timeout(180 * 1000);
+    _at.set_at_timeout(3min);
     int active_contexts_count = 0;
     _is_context_active = _nw->is_active_context(&active_contexts_count, _cid);
 

features/cellular/framework/AT/AT_CellularDevice.cpp

@@ -34,8 +34,9 @@
 using namespace mbed_cellular_util;
 using namespace events;
 using namespace mbed;
+using namespace std::chrono_literals;
 
-#define DEFAULT_AT_TIMEOUT 1000 // at default timeout in milliseconds
+#define DEFAULT_AT_TIMEOUT 1s // at default timeout
 const int MAX_SIM_RESPONSE_LENGTH = 16;
 
 AT_CellularDevice::AT_CellularDevice(FileHandle *fh) :
@@ -388,7 +389,7 @@ void AT_CellularDevice::close_information()
 
 void AT_CellularDevice::set_timeout(int timeout)
 {
-    _default_timeout = timeout;
+    _default_timeout = std::chrono::duration<int, std::milli>(timeout);
 
     _at.set_at_timeout(_default_timeout, true);
 
@@ -420,7 +421,7 @@ nsapi_error_t AT_CellularDevice::init()
             }
         }
         tr_debug("Wait 100ms to init modem");
-        rtos::ThisThread::sleep_for(100); // let modem have time to get ready
+        rtos::ThisThread::sleep_for(100ms); // let modem have time to get ready
     }
 
     return _at.unlock_return_error();
@@ -577,7 +578,7 @@ void AT_CellularDevice::cellular_callback(nsapi_event_t ev, intptr_t ptr, Cellul
         cellular_connection_status_t cell_ev = (cellular_connection_status_t)ev;
         if (cell_ev == CellularDeviceTimeout) {
             cell_callback_data_t *data = (cell_callback_data_t *)ptr;
-            int timeout = *(int *)data->data;
+            auto timeout = *(std::chrono::duration<int, std::milli> *)data->data;
             if (_default_timeout != timeout) {
                 _default_timeout = timeout;
                 _at.set_at_timeout(_default_timeout, true);
@@ -611,7 +612,7 @@ nsapi_error_t AT_CellularDevice::set_baud_rate(int baud_rate)
     _at.set_baud(baud_rate);
 
     // Give some time before starting using the UART with the new baud rate
-    rtos::ThisThread::sleep_for(3000);
+    rtos::ThisThread::sleep_for(3s);
 #else
     // Currently ATHandler only supports BufferedSerial based communication and
     // if serial is disabled, baud rate cannot be set

features/cellular/framework/AT/AT_CellularDevice.h

@@ -197,7 +197,7 @@ class AT_CellularDevice : public CellularDevice {
     AT_CellularInformation *_information;
     AT_CellularContext *_context_list;
 
-    int _default_timeout;
+    std::chrono::duration<int, std::milli> _default_timeout;
     bool _modem_debug_on;
     const intptr_t *_property_array;
 };