Merge pull request #8749 from TeemuKultala/cellular_at_handler_api

0xc0170 · web-flow · commit 671c061c61a5 · 2018-12-20T16:31:06.000Z
Cellular: AT handler API
diff --git a/UNITTESTS/features/cellular/framework/AT/at_cellularbase/unittest.cmake b/UNITTESTS/features/cellular/framework/AT/at_cellularbase/unittest.cmake
@@ -16,6 +16,7 @@ set(unittest-includes ${unittest-includes}
 # Source files
 set(unittest-sources
   ../features/cellular/framework/AT/AT_CellularBase.cpp
+  ../features/cellular/framework/AT/ATHandler_factory.cpp
 )
 
 # Test files
diff --git a/UNITTESTS/features/cellular/framework/AT/at_cellularcontext/unittest.cmake b/UNITTESTS/features/cellular/framework/AT/at_cellularcontext/unittest.cmake
@@ -14,6 +14,7 @@ set(unittest-includes ${unittest-includes}
 # Source files
 set(unittest-sources
   ../features/cellular/framework/AT/AT_CellularContext.cpp
+  ../features/cellular/framework/AT/ATHandler_factory.cpp
   ../features/cellular/framework/common/CellularUtil.cpp
 )
 
diff --git a/UNITTESTS/features/cellular/framework/AT/at_cellulardevice/at_cellulardevicetest.cpp b/UNITTESTS/features/cellular/framework/AT/at_cellulardevice/at_cellulardevicetest.cpp
@@ -61,6 +61,16 @@ TEST_F(TestAT_CellularDevice, test_AT_CellularDevice_get_at_handler)
     EXPECT_TRUE(dev.open_power(&fh1));
 
     ATHandler_stub::fh_value = NULL;
+
+    AT_CellularDevice *dev2 = new AT_CellularDevice(&fh1);
+    EXPECT_TRUE(dev2->open_information(&fh1));
+    ATHandler *at = dev2->get_at_handler();
+    EXPECT_TRUE(at->get_ref_count() == 4);
+    delete dev2;
+    EXPECT_TRUE(at->get_ref_count() == 3);
+    AT_CellularDevice dev3(&fh1);
+    EXPECT_TRUE(dev3.release_at_handler(at) == NSAPI_ERROR_OK);
+    EXPECT_TRUE(ATHandler_stub::ref_count == 2);
 }
 
 TEST_F(TestAT_CellularDevice, test_AT_CellularDevice_open_network)
@@ -211,7 +221,7 @@ TEST_F(TestAT_CellularDevice, test_AT_CellularDevice_close_information)
     AT_CellularBase_stub::handler_value = AT_CellularBase_stub::handler_at_constructor_value;
 
     dev.close_information();
-    EXPECT_TRUE(ATHandler_stub::ref_count == 1);
+    EXPECT_TRUE(ATHandler_stub::ref_count == kATHandler_destructor_ref_ount);
 
     ATHandler_stub::fh_value = NULL;
 }
@@ -276,13 +286,21 @@ TEST_F(TestAT_CellularDevice, test_AT_CellularDevice_create_delete_context)
     FileHandle_stub fh1;
     AT_CellularDevice *dev = new AT_CellularDevice(&fh1);
 
+    ATHandler *at = dev->get_at_handler();
+    EXPECT_TRUE(at->get_ref_count() == 1);
+    EXPECT_TRUE(dev->release_at_handler(at) == NSAPI_ERROR_OK);
+
     CellularContext *ctx = dev->create_context(NULL);
     delete dev;
 
     dev = new AT_CellularDevice(&fh1);
+    at = dev->get_at_handler();
+    EXPECT_TRUE(at->get_ref_count() == 1);
     ctx = dev->create_context(NULL);
     CellularContext *ctx1 = dev->create_context(&fh1);
+    EXPECT_TRUE(at->get_ref_count() == 3);
     CellularContext *ctx2 = dev->create_context(&fh1);
+    EXPECT_TRUE(at->get_ref_count() == 4);
 
     EXPECT_TRUE(ctx);
     EXPECT_TRUE(ctx1);
@@ -293,13 +311,21 @@ TEST_F(TestAT_CellularDevice, test_AT_CellularDevice_create_delete_context)
     EXPECT_TRUE(xx);
 
     dev->delete_context(ctx);
+    EXPECT_TRUE(at->get_ref_count() == 3);
     dev->delete_context(ctx1);
+    EXPECT_TRUE(at->get_ref_count() == 2);
     dev->delete_context(NULL);
+    EXPECT_TRUE(at->get_ref_count() == 2);
     dev->delete_context(ctx2);
+    EXPECT_TRUE(at->get_ref_count() == 1);
 
     ctx = dev->create_context(NULL);
+    EXPECT_TRUE(at->get_ref_count() == 2);
     ctx1 = dev->create_context(&fh1);
+    EXPECT_TRUE(at->get_ref_count() == 3);
     ctx2 = dev->create_context(&fh1);
+    EXPECT_TRUE(at->get_ref_count() == 4);
+    EXPECT_TRUE(dev->release_at_handler(at) == NSAPI_ERROR_OK);
     EXPECT_TRUE(ctx);
     EXPECT_TRUE(ctx1);
     EXPECT_TRUE(ctx1 != ctx);
diff --git a/UNITTESTS/features/cellular/framework/AT/at_cellulardevice/unittest.cmake b/UNITTESTS/features/cellular/framework/AT/at_cellulardevice/unittest.cmake
@@ -18,6 +18,7 @@ set(unittest-includes ${unittest-includes}
 set(unittest-sources
   stubs/randLIB_stub.c
   ../features/cellular/framework/AT/AT_CellularDevice.cpp
+  ../features/cellular/framework/AT/ATHandler_factory.cpp
 )
 
 # Test files
diff --git a/UNITTESTS/features/cellular/framework/AT/athandler/athandlertest.cpp b/UNITTESTS/features/cellular/framework/AT/athandler/athandlertest.cpp
@@ -86,6 +86,38 @@ TEST_F(TestATHandler, test_ATHandler_set_file_handle)
     at.set_file_handle(&fh2);
 }
 
+TEST_F(TestATHandler, test_ATHandler_list)
+{
+    EventQueue que;
+    FileHandle_stub fh1;
+
+    ATHandler::set_at_timeout_list(1000, false);
+    ATHandler::set_debug_list(false);
+
+    ATHandler *at1 = ATHandler::get_instance(&fh1, que, 0, ",", 0, 0);
+    EXPECT_TRUE(at1->get_ref_count() == 1);
+
+    ATHandler::set_at_timeout_list(1000, false);
+    ATHandler::set_debug_list(true);
+
+    EXPECT_TRUE(ATHandler::get_instance(NULL, que, 0, ",", 0, 0) == NULL);
+
+    ATHandler *at2 = ATHandler::get_instance(&fh1, que, 0, ",", 0, 0);
+    EXPECT_TRUE(at1->get_ref_count() == 2);
+    EXPECT_TRUE(at2->get_ref_count() == 2);
+
+    ATHandler::set_at_timeout_list(2000, true);
+    ATHandler::set_debug_list(false);
+
+    EXPECT_TRUE(at1->close() == NSAPI_ERROR_OK);
+    EXPECT_TRUE(at2->get_ref_count() == 1);
+    EXPECT_TRUE(at2->close() == NSAPI_ERROR_OK);
+    EXPECT_TRUE(at1->close() == NSAPI_ERROR_PARAMETER);
+
+    ATHandler::set_at_timeout_list(1000, false);
+    ATHandler::set_debug_list(false);
+}
+
 TEST_F(TestATHandler, test_ATHandler_lock)
 {
     EventQueue que;
diff --git a/UNITTESTS/features/cellular/framework/AT/athandler/unittest.cmake b/UNITTESTS/features/cellular/framework/AT/athandler/unittest.cmake
@@ -14,6 +14,7 @@ set(unittest-includes ${unittest-includes}
 # Source files
 set(unittest-sources
   ../features/cellular/framework/AT/ATHandler.cpp
+  ../features/cellular/framework/AT/ATHandler_factory.cpp
   ../features/cellular/framework/common/CellularUtil.cpp
 )
 
diff --git a/UNITTESTS/stubs/ATHandler_stub.cpp b/UNITTESTS/stubs/ATHandler_stub.cpp
@@ -57,10 +57,11 @@ int ATHandler_stub::urc_amount = 0;
 mbed::Callback<void()> ATHandler_stub::callback[kATHandler_urc_table_max_size];
 char *ATHandler_stub::urc_string_table[kATHandler_urc_table_max_size];
 
-ATHandler::ATHandler(FileHandle *fh, EventQueue &queue, int timeout, const char *output_delimiter, uint16_t send_delay) :
+ATHandler::ATHandler(FileHandle *fh, EventQueue &queue, uint32_t timeout, const char *output_delimiter, uint16_t send_delay) :
     _nextATHandler(0),
     _fileHandle(fh),
-    _queue(queue)
+    _queue(queue),
+    _ref_count(1)
 {
     ATHandler_stub::ref_count = 1;
 
@@ -95,22 +96,25 @@ ATHandler::~ATHandler()
 
 void ATHandler::inc_ref_count()
 {
-    ATHandler_stub::ref_count++;
+    _ref_count++;
+    ATHandler_stub::ref_count = _ref_count;
 }
 
 void ATHandler::dec_ref_count()
 {
-    ATHandler_stub::ref_count--;
+    _ref_count--;
+    ATHandler_stub::ref_count = _ref_count;
 }
 
 int ATHandler::get_ref_count()
 {
-    return ATHandler_stub::ref_count;
+    return _ref_count;
 }
 
 FileHandle *ATHandler::get_file_handle()
 {
-    return ATHandler_stub::fh_value;
+    ATHandler_stub::fh_value = (FileHandle_stub *)_fileHandle;
+    return _fileHandle;
 }
 
 void ATHandler::set_file_handle(FileHandle *fh)
diff --git a/UNITTESTS/stubs/AT_CellularBase_stub.cpp b/UNITTESTS/stubs/AT_CellularBase_stub.cpp
@@ -34,7 +34,8 @@ AT_CellularBase::AT_CellularBase(ATHandler &at) : _at(at)
 
 ATHandler &AT_CellularBase::get_at_handler()
 {
-    return *AT_CellularBase_stub::handler_value;
+    AT_CellularBase_stub::handler_value = &_at;
+    return _at;
 }
 
 device_err_t AT_CellularBase::get_device_error() const
diff --git a/UNITTESTS/stubs/AT_CellularDevice_stub.cpp b/UNITTESTS/stubs/AT_CellularDevice_stub.cpp
@@ -27,22 +27,29 @@ AT_CellularDevice::AT_CellularDevice(FileHandle *fh) : CellularDevice(fh), _netw
     _sim(0), _power(0), _information(0), _context_list(0), _default_timeout(DEFAULT_AT_TIMEOUT),
     _modem_debug_on(false)
 {
-    _atHandlers = new ATHandler(fh, _queue, 0, ",");
 }
 
 AT_CellularDevice::~AT_CellularDevice()
 {
-    delete _atHandlers;
 }
 
 ATHandler *AT_CellularDevice::get_at_handler(FileHandle *fileHandle)
 {
-    return _atHandlers;
+    return ATHandler::get_instance(fileHandle, _queue, _default_timeout, "\r", get_send_delay(), _modem_debug_on);
 }
 
-void AT_CellularDevice::release_at_handler(ATHandler *at_handler)
+ATHandler *AT_CellularDevice::get_at_handler()
 {
+    return get_at_handler(NULL);
+}
 
+nsapi_error_t AT_CellularDevice::release_at_handler(ATHandler *at_handler)
+{
+    if (at_handler) {
+        return at_handler->close();
+    } else {
+        return NSAPI_ERROR_PARAMETER;
+    }
 }
 
 CellularContext *create_context(FileHandle *fh = NULL, const char *apn = MBED_CONF_NSAPI_DEFAULT_CELLULAR_APN)
@@ -57,7 +64,7 @@ void delete_context(CellularContext *context)
 
 CellularNetwork *AT_CellularDevice::open_network(FileHandle *fh)
 {
-    return new AT_CellularNetwork(*_atHandlers);
+    return new AT_CellularNetwork(*ATHandler::get_instance(fh, _queue, _default_timeout, "\r", get_send_delay(), _modem_debug_on));
 }
 
 CellularSMS *AT_CellularDevice::open_sms(FileHandle *fh)
diff --git a/UNITTESTS/target_h/myCellularDevice.h b/UNITTESTS/target_h/myCellularDevice.h
@@ -119,6 +119,14 @@ class myCellularDevice : public CellularDevice {
     {
         CellularDevice::cellular_callback(ev, ptr);
     }
+    virtual ATHandler *get_at_handler()
+    {
+        return NULL;
+    }
+    virtual nsapi_error_t release_at_handler(ATHandler *at_handler)
+    {
+        return NSAPI_ERROR_OK;
+    }
     AT_CellularNetwork *_network;
     AT_CellularContext *_context_list;
 };
diff --git a/features/cellular/framework/API/CellularDevice.h b/features/cellular/framework/API/CellularDevice.h
@@ -21,6 +21,7 @@
 #include "CellularTargets.h"
 #include "CellularStateMachine.h"
 #include "Callback.h"
+#include "ATHandler.h"
 
 namespace mbed {
 
@@ -249,6 +250,20 @@ class CellularDevice {
      */
     virtual CellularContext *get_context_list() const;
 
+    /** Get the current ATHandler instance in use for debug purposes etc.
+     *  Once use has been finished call to release_at_handler() has to be made
+     *
+     *  @return Pointer to the ATHandler in use
+     */
+    virtual ATHandler *get_at_handler() = 0;
+
+    /** Release the ATHandler taken into use with get_at_handler()
+     *
+     *  @param at_handler
+     *  @return NSAPI_ERROR_OK on success, NSAPI_ERROR_PARAMETER on failure
+     */
+    virtual nsapi_error_t release_at_handler(ATHandler *at_handler) = 0;
+
 protected:
     friend class AT_CellularNetwork;
     friend class AT_CellularContext;
diff --git a/features/cellular/framework/AT/ATHandler.cpp b/features/cellular/framework/AT/ATHandler.cpp
@@ -60,7 +60,7 @@ static const uint8_t map_3gpp_errors[][2] =  {
     { 146, 46 }, { 178, 65 }, { 179, 66 }, { 180, 48 }, { 181, 83 }, { 171, 49 },
 };
 
-ATHandler::ATHandler(FileHandle *fh, EventQueue &queue, int timeout, const char *output_delimiter, uint16_t send_delay) :
+ATHandler::ATHandler(FileHandle *fh, EventQueue &queue, uint32_t timeout, const char *output_delimiter, uint16_t send_delay) :
     _nextATHandler(0),
     _fileHandle(fh),
     _queue(queue),
diff --git a/features/cellular/framework/AT/ATHandler.h b/features/cellular/framework/AT/ATHandler.h
@@ -74,7 +74,7 @@ class ATHandler {
      *  @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, int timeout, const char *output_delimiter, uint16_t send_delay = 0);
+    ATHandler(FileHandle *fh, events::EventQueue &queue, uint32_t timeout, const char *output_delimiter, uint16_t send_delay = 0);
     virtual ~ATHandler();
 
     /** Return used file handle.
@@ -83,6 +83,32 @@ class ATHandler {
      */
     FileHandle *get_file_handle();
 
+    /** Get a new ATHandler instance, and update the linked list. Once the use of the ATHandler
+     *  has finished, call to close() has to be made
+     *
+     *  @param fileHandle       filehandle used for reading AT responses and writing AT commands.
+     *                          If there is already an ATHandler with the same fileHandle pointer,
+     *                          then a pointer to that ATHandler instance will be returned with
+     *                          that ATHandler's queue, timeout, delimiter, send_delay and debug_on
+     *                          values
+     *  @param queue            Event queue used to transfer sigio events to this thread
+     *  @param timeout          Timeout when reading for AT response
+     *  @param 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
+     *  @param debug_on         Set true to enable debug traces
+     *  @return                 NULL, if fileHandle is not set, or a pointer to an existing ATHandler, if the fileHandle is
+     *                          already in use. Otherwise a pointer to a new ATHandler instance is returned
+     */
+    static ATHandler *get_instance(FileHandle *fileHandle, events::EventQueue &queue, uint32_t timeout,
+                                   const char *delimiter, uint16_t send_delay, bool debug_on);
+
+    /** Close and delete the current ATHandler instance, if the reference count to it is 0.
+     *  Close() can be only called, if the ATHandler was opened with get_instance()
+     *
+     *  @return NSAPI_ERROR_OK on success, NSAPI_ERROR_PARAMETER on failure
+     */
+    nsapi_error_t close();
+
     /** Locks the mutex for file handle if AT_HANDLER_MUTEX is defined.
      */
     void lock();
@@ -127,10 +153,14 @@ class ATHandler {
     device_err_t get_last_device_error() const;
 
     /** Increase reference count. Used for counting references to this instance.
+     *  Note that this should be used with care, if the ATHandler was taken into use
+     *  with get_instance()
      */
     void inc_ref_count();
 
     /** Decrease reference count. Used for counting references to this instance.
+     *  Note that this should be used with care, if the ATHandler was taken into use
+     *  with get_instance()
      */
     void dec_ref_count();
 
@@ -147,6 +177,13 @@ class ATHandler {
      */
     void set_at_timeout(uint32_t timeout_milliseconds, bool default_timeout = false);
 
+    /** Set timeout in milliseconds for all ATHandlers in the _atHandlers list
+     *
+     *  @param timeout_milliseconds  Timeout in milliseconds
+     *  @param default_timeout       Store as default timeout
+     */
+    static void set_at_timeout_list(uint32_t timeout_milliseconds, bool default_timeout = false);
+
     /** Restore timeout to previous timeout. Handy if there is a need to change timeout temporarily.
      */
     void restore_at_timeout();
@@ -222,6 +259,8 @@ class ATHandler {
     int32_t _ref_count;
     bool _is_fh_usable;
 
+    static ATHandler *_atHandlers;
+
     //*************************************
 public:
 
@@ -398,6 +437,12 @@ class ATHandler {
      */
     void set_debug(bool debug_on);
 
+    /** Set debug_on for all ATHandlers in the _atHandlers list
+     *
+     *  @param debug_on Set true to enable debug traces
+     */
+    static void set_debug_list(bool debug_on);
+
 private:
 
     // should fit any prefix and int
diff --git a/features/cellular/framework/AT/ATHandler_factory.cpp b/features/cellular/framework/AT/ATHandler_factory.cpp
diff --git a/features/cellular/framework/AT/AT_CellularDevice.cpp b/features/cellular/framework/AT/AT_CellularDevice.cpp
diff --git a/features/cellular/framework/AT/AT_CellularDevice.h b/features/cellular/framework/AT/AT_CellularDevice.h

Original file line number	Diff line number	Diff line change
`@@ -16,6 +16,7 @@ set(unittest-includes ${unittest-includes}`
`16`	`16`	`# Source files`
`17`	`17`	`set(unittest-sources`
`18`	`18`	`../features/cellular/framework/AT/AT_CellularBase.cpp`
	`19`	`+ ../features/cellular/framework/AT/ATHandler_factory.cpp`
`19`	`20`	`)`
`20`	`21`
`21`	`22`	`# Test files`
Original file line number	Diff line number	Diff line change
`@@ -14,6 +14,7 @@ set(unittest-includes ${unittest-includes}`
`14`	`14`	`# Source files`
`15`	`15`	`set(unittest-sources`
`16`	`16`	`../features/cellular/framework/AT/AT_CellularContext.cpp`
	`17`	`+ ../features/cellular/framework/AT/ATHandler_factory.cpp`
`17`	`18`	`../features/cellular/framework/common/CellularUtil.cpp`
`18`	`19`	`)`
`19`	`20`
Original file line number	Diff line number	Diff line change
`@@ -18,6 +18,7 @@ set(unittest-includes ${unittest-includes}`
`18`	`18`	`set(unittest-sources`
`19`	`19`	`stubs/randLIB_stub.c`
`20`	`20`	`../features/cellular/framework/AT/AT_CellularDevice.cpp`
	`21`	`+ ../features/cellular/framework/AT/ATHandler_factory.cpp`
`21`	`22`	`)`
`22`	`23`
`23`	`24`	`# Test files`
Original file line number	Diff line number	Diff line change
`@@ -57,10 +57,11 @@ int ATHandler_stub::urc_amount = 0;`
`57`	`57`	`mbed::Callback<void()> ATHandler_stub::callback[kATHandler_urc_table_max_size];`
`58`	`58`	`char *ATHandler_stub::urc_string_table[kATHandler_urc_table_max_size];`
`59`	`59`
`60`		`-ATHandler::ATHandler(FileHandle fh, EventQueue &queue, int timeout, const char output_delimiter, uint16_t send_delay) :`
	`60`	`+ATHandler::ATHandler(FileHandle fh, EventQueue &queue, uint32_t timeout, const char output_delimiter, uint16_t send_delay) :`
`61`	`61`	`_nextATHandler(0),`
`62`	`62`	`_fileHandle(fh),`
`63`		`- _queue(queue)`
	`63`	`+ _queue(queue),`
	`64`	`+ _ref_count(1)`
`64`	`65`	`{`
`65`	`66`	`ATHandler_stub::ref_count = 1;`
`66`	`67`
`@@ -95,22 +96,25 @@ ATHandler::~ATHandler()`
`95`	`96`
`96`	`97`	`void ATHandler::inc_ref_count()`
`97`	`98`	`{`
`98`		`- ATHandler_stub::ref_count++;`
	`99`	`+ _ref_count++;`
	`100`	`+ ATHandler_stub::ref_count = _ref_count;`
`99`	`101`	`}`
`100`	`102`
`101`	`103`	`void ATHandler::dec_ref_count()`
`102`	`104`	`{`
`103`		`- ATHandler_stub::ref_count--;`
	`105`	`+ _ref_count--;`
	`106`	`+ ATHandler_stub::ref_count = _ref_count;`
`104`	`107`	`}`
`105`	`108`
`106`	`109`	`int ATHandler::get_ref_count()`
`107`	`110`	`{`
`108`		`- return ATHandler_stub::ref_count;`
	`111`	`+ return _ref_count;`
`109`	`112`	`}`
`110`	`113`
`111`	`114`	`FileHandle *ATHandler::get_file_handle()`
`112`	`115`	`{`
`113`		`- return ATHandler_stub::fh_value;`
	`116`	`+ ATHandler_stub::fh_value = (FileHandle_stub *)_fileHandle;`
	`117`	`+ return _fileHandle;`
`114`	`118`	`}`
`115`	`119`
`116`	`120`	`void ATHandler::set_file_handle(FileHandle *fh)`
Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,8 @@ AT_CellularBase::AT_CellularBase(ATHandler &at) : _at(at)`
`34`	`34`
`35`	`35`	`ATHandler &AT_CellularBase::get_at_handler()`
`36`	`36`	`{`
`37`		`- return *AT_CellularBase_stub::handler_value;`
	`37`	`+ AT_CellularBase_stub::handler_value = &_at;`
	`38`	`+ return _at;`
`38`	`39`	`}`
`39`	`40`
`40`	`41`	`device_err_t AT_CellularBase::get_device_error() const`
Original file line number	Diff line number	Diff line change
`@@ -27,22 +27,29 @@ AT_CellularDevice::AT_CellularDevice(FileHandle *fh) : CellularDevice(fh), _netw`
`27`	`27`	`_sim(0), _power(0), _information(0), _context_list(0), _default_timeout(DEFAULT_AT_TIMEOUT),`
`28`	`28`	`_modem_debug_on(false)`
`29`	`29`	`{`
`30`		`- _atHandlers = new ATHandler(fh, _queue, 0, ",");`
`31`	`30`	`}`
`32`	`31`
`33`	`32`	`AT_CellularDevice::~AT_CellularDevice()`
`34`	`33`	`{`
`35`		`- delete _atHandlers;`
`36`	`34`	`}`
`37`	`35`
`38`	`36`	`ATHandler AT_CellularDevice::get_at_handler(FileHandle fileHandle)`
`39`	`37`	`{`
`40`		`- return _atHandlers;`
	`38`	`+ return ATHandler::get_instance(fileHandle, _queue, _default_timeout, "\r", get_send_delay(), _modem_debug_on);`
`41`	`39`	`}`
`42`	`40`
`43`		`-void AT_CellularDevice::release_at_handler(ATHandler *at_handler)`
	`41`	`+ATHandler *AT_CellularDevice::get_at_handler()`
`44`	`42`	`{`
	`43`	`+ return get_at_handler(NULL);`
	`44`	`+}`
`45`	`45`
	`46`	`+nsapi_error_t AT_CellularDevice::release_at_handler(ATHandler *at_handler)`
	`47`	`+{`
	`48`	`+ if (at_handler) {`
	`49`	`+ return at_handler->close();`
	`50`	`+ } else {`
	`51`	`+ return NSAPI_ERROR_PARAMETER;`
	`52`	`+ }`
`46`	`53`	`}`
`47`	`54`
`48`	`55`	`CellularContext create_context(FileHandle fh = NULL, const char *apn = MBED_CONF_NSAPI_DEFAULT_CELLULAR_APN)`
`@@ -57,7 +64,7 @@ void delete_context(CellularContext *context)`
`57`	`64`
`58`	`65`	`CellularNetwork AT_CellularDevice::open_network(FileHandle fh)`
`59`	`66`	`{`
`60`		`- return new AT_CellularNetwork(*_atHandlers);`
	`67`	`+ return new AT_CellularNetwork(*ATHandler::get_instance(fh, _queue, _default_timeout, "\r", get_send_delay(), _modem_debug_on));`
`61`	`68`	`}`
`62`	`69`
`63`	`70`	`CellularSMS AT_CellularDevice::open_sms(FileHandle fh)`