Revision 45:63eba30af193, committed 2019-08-07

Comitter:

Daniel_Lee

Date:

Wed Aug 07 06:31:31 2019 +0000

Parent:

38:84d8baae4f0b

Child:

46:387c2d922a4a

Commit message:

Update for Mbed OS 5.12.x; This code was tested on Mbed OS 5.12.2, please check code revision!

Changed in this revision

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/SERCOMM/TPB23/SERCOMM_TPB23.cpp	Wed Aug 07 06:31:31 2019 +0000
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) 2017, Arm Limited and affiliates.
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "SERCOMM_TPB23_CellularNetwork.h"
+#include "SERCOMM_TPB23_CellularContext.h"
+#include "SERCOMM_TPB23_CellularInformation.h"
+#include "SERCOMM_TPB23.h"
+#include "CellularLog.h"
+
+#define CONNECT_DELIM         "\r\n"
+#define CONNECT_BUFFER_SIZE   (1280 + 80 + 80) // AT response + sscanf format
+#define CONNECT_TIMEOUT       8000
+
+using namespace events;
+using namespace mbed;
+
+static const intptr_t cellular_properties[AT_CellularBase::PROPERTY_MAX] = {
+    AT_CellularNetwork::RegistrationModeLAC,        // C_EREG
+    AT_CellularNetwork::RegistrationModeDisable,    // C_GREG
+    AT_CellularNetwork::RegistrationModeDisable,    // C_REG
+    1,  // AT_CGSN_WITH_TYPE
+    1,  // AT_CGDATA
+    0,  // AT_CGAUTH
+    1,  // AT_CNMI
+    1,  // AT_CSMP
+    1,  // AT_CMGF
+    1,  // AT_CSDH
+    1,  // PROPERTY_IPV4_STACK
+    0,  // PROPERTY_IPV6_STACK
+    0,  // PROPERTY_IPV4V6_STACK
+    0,  // PROPERTY_NON_IP_PDP_TYPE
+    1,  // PROPERTY_AT_CGEREP
+};
+
+SERCOMM_TPB23::SERCOMM_TPB23(FileHandle *fh) : AT_CellularDevice(fh)
+{
+    AT_CellularBase::set_cellular_properties(cellular_properties);
+}
+
+nsapi_error_t SERCOMM_TPB23::get_sim_state(SimState &state)
+{
+    _at->lock();
+    _at->flush();
+    _at->cmd_start("AT+NCCID?");
+    _at->cmd_stop();
+    _at->resp_start("+NCCID:");
+    if (_at->info_resp()) {
+        state = SimStateReady;
+    } else {
+        tr_warn("SIM not readable.");
+        state = SimStateUnknown; // SIM may not be ready yet
+    }
+    _at->resp_stop();
+    return _at->unlock_return_error();
+}
+
+AT_CellularNetwork *SERCOMM_TPB23::open_network_impl(ATHandler &at)
+{
+    return new SERCOMM_TPB23_CellularNetwork(at);
+}
+
+AT_CellularContext *SERCOMM_TPB23::create_context_impl(ATHandler &at, const char *apn, bool cp_req, bool nonip_req)
+{
+    return new SERCOMM_TPB23_CellularContext(at, this, apn, cp_req, nonip_req);
+}
+
+AT_CellularInformation *SERCOMM_TPB23::open_information_impl(ATHandler &at)
+{
+    return new SERCOMM_TPB23_CellularInformation(at);
+}
+
+nsapi_error_t SERCOMM_TPB23::init()
+{
+    _at->lock();
+    _at->flush();
+    _at->cmd_start("AT");
+    _at->cmd_stop_read_resp();
+
+    _at->cmd_start("AT+CMEE="); // verbose responses
+    _at->write_int(1);
+    _at->cmd_stop_read_resp();
+
+    return _at->unlock_return_error();
+}
+
+#if MBED_CONF_SERCOMM_TPB23_PROVIDE_DEFAULT
+#include "UARTSerial.h"
+CellularDevice *CellularDevice::get_default_instance()
+{
+    static UARTSerial serial(MBED_CONF_SERCOMM_TPB23_TX, MBED_CONF_SERCOMM_TPB23_RX, MBED_CONF_SERCOMM_TPB23_BAUDRATE);
+    static SERCOMM_TPB23 device(&serial);
+    return &device;
+}
+#endif

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/SERCOMM/TPB23/SERCOMM_TPB23.h	Wed Aug 07 06:31:31 2019 +0000
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2017, Arm Limited and affiliates.
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef SERCOMM_TPB23_H_
+#define SERCOMM_TPB23_H_
+
+#include "AT_CellularDevice.h"
+
+namespace mbed {
+
+class SERCOMM_TPB23 : public AT_CellularDevice {
+public:
+    SERCOMM_TPB23(FileHandle *fh);
+
+public: // AT_CellularDevice
+    virtual nsapi_error_t get_sim_state(SimState &state);
+
+protected: // AT_CellularDevice
+    virtual AT_CellularNetwork *open_network_impl(ATHandler &at);
+	virtual AT_CellularContext *create_context_impl(ATHandler &at, const char *apn, bool cp_req = false, bool nonip_req = false);
+    virtual AT_CellularInformation *open_information_impl(ATHandler &at);
+    virtual nsapi_error_t init();
+
+public: // NetworkInterface
+    void handle_urc(FileHandle *fh);
+};
+} // namespace mbed
+#endif // SERCOMM_TPB23_H_

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/SERCOMM/TPB23/SERCOMM_TPB23_CellularContext.cpp	Wed Aug 07 06:31:31 2019 +0000
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2018, Arm Limited and affiliates.
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "SERCOMM_TPB23_CellularContext.h"
+#include "SERCOMM_TPB23_CellularStack.h"
+#include "CellularLog.h"
+
+namespace mbed {
+
+SERCOMM_TPB23_CellularContext::SERCOMM_TPB23_CellularContext(ATHandler &at, CellularDevice *device, const char *apn, bool cp_req, bool nonip_req) :
+    AT_CellularContext(at, device, apn, cp_req, nonip_req)
+{
+}
+
+SERCOMM_TPB23_CellularContext::~SERCOMM_TPB23_CellularContext()
+{
+}
+
+#if !NSAPI_PPP_AVAILABLE
+NetworkStack *SERCOMM_TPB23_CellularContext::get_stack()
+{
+    if (_pdp_type == NON_IP_PDP_TYPE || _cp_in_use) {
+        tr_error("Requesting stack for NON-IP context! Should request control plane netif: get_cp_netif()");
+        return NULL;
+    }
+
+    if (!_stack) {
+        _stack = new SERCOMM_TPB23_CellularStack(_at, _cid, (nsapi_ip_stack_t)_pdp_type);
+    }
+    return _stack;
+}
+#endif // #if !NSAPI_PPP_AVAILABLE
+
+} /* namespace mbed */

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/SERCOMM/TPB23/SERCOMM_TPB23_CellularContext.h	Wed Aug 07 06:31:31 2019 +0000
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2018, Arm Limited and affiliates.
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef SERCOMM_TPB23_CELLULARCONTEXT_H_
+#define SERCOMM_TPB23_CELLULARCONTEXT_H_
+
+#include "AT_CellularContext.h"
+
+namespace mbed {
+
+class SERCOMM_TPB23_CellularContext: public AT_CellularContext {
+public:
+    SERCOMM_TPB23_CellularContext(ATHandler &at, CellularDevice *device, const char *apn, bool cp_req = false, bool nonip_req = false);
+    virtual ~SERCOMM_TPB23_CellularContext();
+
+protected:
+#if !NSAPI_PPP_AVAILABLE
+    virtual NetworkStack *get_stack();
+#endif // #if !NSAPI_PPP_AVAILABLE
+};
+
+} /* namespace mbed */
+
+#endif // SERCOMM_TPB23_CELLULARCONTEXT_H_

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/SERCOMM/TPB23/SERCOMM_TPB23_CellularInformation.cpp	Wed Aug 07 06:31:31 2019 +0000
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2017, Arm Limited and affiliates.
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "SERCOMM_TPB23_CellularInformation.h"
+
+namespace mbed {
+
+SERCOMM_TPB23_CellularInformation::SERCOMM_TPB23_CellularInformation(ATHandler &at) : AT_CellularInformation(at)
+{
+}
+
+SERCOMM_TPB23_CellularInformation::~SERCOMM_TPB23_CellularInformation()
+{
+}
+
+nsapi_error_t SERCOMM_TPB23_CellularInformation::get_iccid(char *buf, size_t buf_size)
+{
+    _at.lock();
+    _at.cmd_start("AT+NCCID?");
+    _at.cmd_stop();
+    _at.resp_start("+NCCID:");
+    _at.read_string(buf, buf_size);
+    _at.resp_stop();
+    return _at.unlock_return_error();
+}
+
+} /* namespace mbed */

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/SERCOMM/TPB23/SERCOMM_TPB23_CellularInformation.h	Wed Aug 07 06:31:31 2019 +0000
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2017, Arm Limited and affiliates.
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef SERCOMM_TPB23_CELLULARINFORMATION_H_
+#define SERCOMM_TPB23_CELLULARINFORMATION_H_
+
+#include "AT_CellularInformation.h"
+
+namespace mbed {
+
+class SERCOMM_TPB23_CellularInformation : public AT_CellularInformation {
+public:
+    SERCOMM_TPB23_CellularInformation(ATHandler &at);
+    virtual ~SERCOMM_TPB23_CellularInformation();
+
+public:
+    virtual nsapi_error_t get_iccid(char *buf, size_t buf_size);
+};
+
+} /* namespace mbed */
+#endif // SERCOMM_TPB23_CELLULARINFORMATION_H_

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/SERCOMM/TPB23/SERCOMM_TPB23_CellularNetwork.cpp	Wed Aug 07 06:31:31 2019 +0000
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2017, Arm Limited and affiliates.
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "SERCOMM_TPB23_CellularNetwork.h"
+
+using namespace mbed;
+
+SERCOMM_TPB23_CellularNetwork::SERCOMM_TPB23_CellularNetwork(ATHandler &atHandler) : AT_CellularNetwork(atHandler)
+{
+    _op_act = RAT_NB1;
+}
+
+SERCOMM_TPB23_CellularNetwork::~SERCOMM_TPB23_CellularNetwork()
+{
+}
+
+nsapi_error_t SERCOMM_TPB23_CellularNetwork::set_access_technology_impl(RadioAccessTechnology opRat)
+{
+    if (opRat != RAT_NB1) {
+        // only rat that is supported by this modem
+        _op_act = RAT_NB1;
+        return NSAPI_ERROR_UNSUPPORTED;
+    }
+
+    return NSAPI_ERROR_OK;
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/SERCOMM/TPB23/SERCOMM_TPB23_CellularNetwork.h	Wed Aug 07 06:31:31 2019 +0000
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2017, Arm Limited and affiliates.
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef SERCOMM_TPB23_CELLULAR_NETWORK_H_
+#define SERCOMM_TPB23_CELLULAR_NETWORK_H_
+
+#include "AT_CellularNetwork.h"
+
+namespace mbed {
+
+class SERCOMM_TPB23_CellularNetwork : public AT_CellularNetwork {
+public:
+    SERCOMM_TPB23_CellularNetwork(ATHandler &atHandler);
+    virtual ~SERCOMM_TPB23_CellularNetwork();
+
+protected:
+    virtual nsapi_error_t set_access_technology_impl(RadioAccessTechnology opRat);
+
+};
+} // namespace mbed
+#endif // SERCOMM_TPB23_CELLULAR_NETWORK_H_

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/SERCOMM/TPB23/SERCOMM_TPB23_CellularStack.cpp	Wed Aug 07 06:31:31 2019 +0000
@@ -0,0 +1,255 @@
+/*
+ * Copyright (c) 2017, Arm Limited and affiliates.
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "SERCOMM_TPB23_CellularStack.h"
+#include "CellularUtil.h"
+#include "CellularLog.h"
+
+#define PACKET_SIZE_MAX 1500  //TPB23 Range is 12-1500
+
+using namespace mbed;
+using namespace mbed_cellular_util;
+
+SERCOMM_TPB23_CellularStack::SERCOMM_TPB23_CellularStack(ATHandler &atHandler, int cid, nsapi_ip_stack_t stack_type) : AT_CellularStack(atHandler, cid, stack_type)
+{
+    _at.set_urc_handler("+NSONMI:", mbed::Callback<void()>(this, &SERCOMM_TPB23_CellularStack::urc_nsonmi));
+}
+
+SERCOMM_TPB23_CellularStack::~SERCOMM_TPB23_CellularStack()
+{
+}
+
+nsapi_error_t SERCOMM_TPB23_CellularStack::socket_listen(nsapi_socket_t handle, int backlog)
+{
+    return NSAPI_ERROR_UNSUPPORTED;
+}
+
+nsapi_error_t SERCOMM_TPB23_CellularStack::socket_accept(void *server, void **socket, SocketAddress *addr)
+{
+    return NSAPI_ERROR_UNSUPPORTED;
+}
+
+nsapi_error_t SERCOMM_TPB23_CellularStack::socket_connect(nsapi_socket_t handle, const SocketAddress &address)
+{
+    CellularSocket *socket = (CellularSocket *)handle;
+
+    _at.lock();
+    if (!socket->created) {
+        const nsapi_error_t error_create = create_socket_impl(socket);
+        if (error_create != NSAPI_ERROR_OK) {
+            return error_create;
+        }
+    }
+
+    _at.cmd_start("AT+NSOCO=");
+    _at.write_int(socket->id);
+    _at.write_string(address.get_ip_address(), false);
+    _at.write_int(address.get_port());
+    _at.cmd_stop();
+    _at.resp_start();
+    _at.resp_stop();
+    _at.unlock();
+
+    if (_at.get_last_error() == NSAPI_ERROR_OK) {
+        socket->remoteAddress = address;
+        socket->connected = true;
+        return NSAPI_ERROR_OK;
+    }
+
+    return NSAPI_ERROR_NO_CONNECTION;
+}
+
+void SERCOMM_TPB23_CellularStack::urc_nsonmi()
+{
+    int sock_id = _at.read_int();
+
+    for (int i = 0; i < get_max_socket_count(); i++) {
+        CellularSocket *sock = _socket[i];
+        if (sock && sock->id == sock_id) {
+            if (sock->_cb) {
+                sock->_cb(sock->_data);
+            }
+            break;
+        }
+    }
+}
+
+int SERCOMM_TPB23_CellularStack::get_max_socket_count()
+{
+    return TPB23_SOCKET_MAX;
+}
+
+bool SERCOMM_TPB23_CellularStack::is_protocol_supported(nsapi_protocol_t protocol)
+{
+    return (protocol == NSAPI_UDP || protocol == NSAPI_TCP);
+}
+
+nsapi_error_t SERCOMM_TPB23_CellularStack::socket_close_impl(int sock_id)
+{
+    _at.cmd_start("AT+NSOCL=");
+    _at.write_int(sock_id);
+    _at.cmd_stop_read_resp();
+
+    tr_info("Close socket: %d error: %d", sock_id, _at.get_last_error());
+
+    return _at.get_last_error();
+}
+
+nsapi_error_t SERCOMM_TPB23_CellularStack::create_socket_impl(CellularSocket *socket)
+{
+    int sock_id = -1;
+    bool socketOpenWorking = false;
+
+    if (socket->proto == NSAPI_UDP) {
+        _at.cmd_start("AT+NSOCR=DGRAM,17,");
+    } else if (socket->proto == NSAPI_TCP) {
+        _at.cmd_start("AT+NSOCR=STREAM,6,");
+    } else {
+        return NSAPI_ERROR_PARAMETER;
+    }
+    _at.write_int(socket->localAddress.get_port());
+    _at.write_int(1);
+    _at.cmd_stop();
+    _at.resp_start();
+    sock_id = _at.read_int();
+    _at.resp_stop();
+
+    socketOpenWorking = (_at.get_last_error() == NSAPI_ERROR_OK);
+
+    if (!socketOpenWorking) {
+        _at.cmd_start("AT+NSOCL=0");
+        _at.cmd_stop_read_resp();
+
+        if (socket->proto == NSAPI_UDP) {
+            _at.cmd_start("AT+NSOCR=DGRAM,17,");
+        } else if (socket->proto == NSAPI_TCP) {
+            _at.cmd_start("AT+NSOCR=STREAM,6,");
+        }
+        _at.write_int(socket->localAddress.get_port());
+        _at.write_int(1);
+        _at.cmd_stop();
+        _at.resp_start();
+        sock_id = _at.read_int();
+        _at.resp_stop();
+
+        socketOpenWorking = (_at.get_last_error() == NSAPI_ERROR_OK);
+    }
+
+    if (!socketOpenWorking || (sock_id == -1)) {
+        tr_error("Socket create failed!");
+        return NSAPI_ERROR_NO_SOCKET;
+    }
+
+    // Check for duplicate socket id delivered by modem
+    for (int i = 0; i < TPB23_SOCKET_MAX; i++) {
+        CellularSocket *sock = _socket[i];
+        if (sock && sock->created && sock->id == sock_id) {
+            tr_error("Duplicate socket index: %d created:%d, sock_id: %d", i, sock->created, sock_id);
+            return NSAPI_ERROR_NO_SOCKET;
+        }
+    }
+
+    tr_info("Socket create id: %d", sock_id);
+
+    socket->id = sock_id;
+    socket->created = true;
+
+    return NSAPI_ERROR_OK;
+}
+
+nsapi_size_or_error_t SERCOMM_TPB23_CellularStack::socket_sendto_impl(CellularSocket *socket, const SocketAddress &address,
+                                                                     const void *data, nsapi_size_t size)
+{
+    int sent_len = 0;
+
+    if (size > PACKET_SIZE_MAX) {
+        return NSAPI_ERROR_PARAMETER;
+    }
+
+    char *hexstr = new char[size * 2 + 1];
+    int hexlen = char_str_to_hex_str((const char *)data, size, hexstr);
+    // NULL terminated for write_string
+    hexstr[hexlen] = 0;
+
+    if (socket->proto == NSAPI_UDP) {
+        _at.cmd_start("AT+NSOST=");
+        _at.write_int(socket->id);
+        _at.write_string(address.get_ip_address(), false);
+        _at.write_int(address.get_port());
+        _at.write_int(size);
+    } else if (socket->proto == NSAPI_TCP) {
+        _at.cmd_start("AT+NSOSD=");
+        _at.write_int(socket->id);
+        _at.write_int(size);
+    } else {
+        delete [] hexstr;
+        return NSAPI_ERROR_PARAMETER;
+    }
+
+    _at.write_string(hexstr, false);
+    _at.cmd_stop();
+    _at.resp_start();
+    // skip socket id
+    _at.skip_param();
+    sent_len = _at.read_int();
+    _at.resp_stop();
+
+    delete [] hexstr;
+
+    if (_at.get_last_error() == NSAPI_ERROR_OK) {
+        return sent_len;
+    }
+
+    return _at.get_last_error();
+}
+
+nsapi_size_or_error_t SERCOMM_TPB23_CellularStack::socket_recvfrom_impl(CellularSocket *socket, SocketAddress *address,
+                                                                       void *buffer, nsapi_size_t size)
+{
+    nsapi_size_or_error_t recv_len = 0;
+    int port;
+    char ip_address[NSAPI_IP_SIZE];
+
+    _at.cmd_start("AT+NSORF=");
+    _at.write_int(socket->id);
+    _at.write_int(size <= PACKET_SIZE_MAX ? size : PACKET_SIZE_MAX);
+    _at.cmd_stop();
+    _at.resp_start();
+    // receiving socket id
+    _at.skip_param();
+    _at.read_string(ip_address, sizeof(ip_address));
+    port = _at.read_int();
+    recv_len = _at.read_int();
+    int hexlen = _at.read_hex_string((char *)buffer, size);
+    // remaining length
+    _at.skip_param();
+    _at.resp_stop();
+
+    if (!recv_len || (recv_len == -1) || (_at.get_last_error() != NSAPI_ERROR_OK)) {
+        return NSAPI_ERROR_WOULD_BLOCK;
+    }
+
+    if (address) {
+        address->set_ip_address(ip_address);
+        address->set_port(port);
+    }
+
+    if (recv_len != hexlen) {
+        tr_error("Not received as much data as expected. Should receive: %d bytes, received: %d bytes", recv_len, hexlen);
+    }
+    return recv_len;
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/SERCOMM/TPB23/SERCOMM_TPB23_CellularStack.h	Wed Aug 07 06:31:31 2019 +0000
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2017, Arm Limited and affiliates.
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef SERCOMM_TPB23_CELLULARSTACK_H_
+#define SERCOMM_TPB23_CELLULARSTACK_H_
+
+#include "AT_CellularStack.h"
+
+#define TPB23_SOCKET_MAX 7
+
+namespace mbed {
+
+class SERCOMM_TPB23_CellularStack : public AT_CellularStack {
+public:
+    SERCOMM_TPB23_CellularStack(ATHandler &atHandler, int cid, nsapi_ip_stack_t stack_type);
+    virtual ~SERCOMM_TPB23_CellularStack();
+
+protected: // NetworkStack
+
+    virtual nsapi_error_t socket_listen(nsapi_socket_t handle, int backlog);
+
+    virtual nsapi_error_t socket_accept(nsapi_socket_t server,
+                                        nsapi_socket_t *handle, SocketAddress *address = 0);
+
+    virtual nsapi_error_t socket_connect(nsapi_socket_t handle, const SocketAddress &address);
+
+protected: // AT_CellularStack
+
+    virtual int get_max_socket_count();
+
+    virtual bool is_protocol_supported(nsapi_protocol_t protocol);
+
+    virtual nsapi_error_t socket_close_impl(int sock_id);
+
+    virtual nsapi_error_t create_socket_impl(CellularSocket *socket);
+
+    virtual nsapi_size_or_error_t socket_sendto_impl(CellularSocket *socket, const SocketAddress &address,
+                                                     const void *data, nsapi_size_t size);
+
+    virtual nsapi_size_or_error_t socket_recvfrom_impl(CellularSocket *socket, SocketAddress *address,
+                                                       void *buffer, nsapi_size_t size);
+
+private:
+    // URC handlers
+    void urc_nsonmi();
+};
+} // namespace mbed
+#endif /* SERCOMM_TPB23_CELLULARSTACK_H_ */

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/SERCOMM/TPB23/mbed_lib.json	Wed Aug 07 06:31:31 2019 +0000
@@ -0,0 +1,29 @@
+{
+    "name": "SERCOMM_TPB23",
+    "config": {
+        "tx": {
+            "help": "TX pin for serial connection. D1 assumed if Arduino Form Factor, needs to be set/overwritten otherwise.",
+            "value": null
+        },
+        "rx": {
+            "help": "RX pin for serial connection. D0 assumed if Arduino Form Factor, needs to be set/overwritten otherwise.",
+            "value": null
+        },
+        "rts": {
+            "help": "RTS pin for serial connection",
+            "value": null
+        },
+        "cts": {
+            "help": "CTS pin for serial connection",
+            "value": null
+        },
+        "baudrate" : {
+            "help": "Serial connection baud rate",
+            "value": 9600
+        },
+        "provide-default": {
+            "help": "Provide as default CellularDevice [true/false]",
+            "value": false
+        }
+    }
+}

--- a/main.cpp	Tue Apr 30 08:01:58 2019 +0100
+++ b/main.cpp	Wed Aug 07 06:31:31 2019 +0000
@@ -206,6 +206,9 @@
 
 int main()
 {
+    DigitalOut TPB23_RESET(A1);
+    TPB23_RESET = 0;    /* 0: Standby 1: Reset */
+    
     print_function("\n\nmbed-os-example-cellular\n");
     print_function("\n\nBuilt: %s, %s\n", __DATE__, __TIME__);
 #ifdef MBED_CONF_NSAPI_DEFAULT_CELLULAR_PLMN

--- a/mbed_app.json	Tue Apr 30 08:01:58 2019 +0100
+++ b/mbed_app.json	Wed Aug 07 06:31:31 2019 +0000
@@ -18,21 +18,24 @@
     "target_overrides": {
         "*": {
             "target.network-default-interface-type": "CELLULAR",
-            "mbed-trace.enable": false,
+            "mbed-trace.enable": true,
             "lwip.ipv4-enabled": true,
             "lwip.ethernet-enabled": false,
-            "lwip.ppp-enabled": true,
+            "lwip.ppp-enabled": false,
             "lwip.tcp-enabled": true,
             "platform.stdio-convert-newlines": true,
             "platform.stdio-baud-rate": 115200,
-            "platform.default-serial-baud-rate": 115200,
+            "platform.default-serial-baud-rate": 9600,
             "platform.stdio-buffered-serial": true,
             "cellular.debug-at": false,
             "nsapi.default-cellular-plmn": 0,
             "nsapi.default-cellular-sim-pin": "\"1234\"",
             "nsapi.default-cellular-apn": 0,
             "nsapi.default-cellular-username": 0,
-            "nsapi.default-cellular-password": 0
+            "nsapi.default-cellular-password": 0,
+            "SERCOMM_TPB23.tx"               : "D1",
+            "SERCOMM_TPB23.rx"               : "D0",
+            "SERCOMM_TPB23.provide-default"  : true
         }
     }
 }