Connections

Connections are essential feature of WiFi device and middleware. It is developed with strong focus on its performance and since it may interact with huge amount of data, it tries to use zero-copy (when available) feature, to decrease processing time.

GSM AT Firmware by default supports up to 5 connections being active at the same time and supports:

Up to 5 TCP connections active at the same time
Up to 5 UDP connections active at the same time
Up to 1 SSL connection active at a time

Note

Client or server connections are available. Same API function call are used to send/receive data or close connection.

Architecture of the connection API is using callback event functions. This allows maximal optimization in terms of responsiveness on different kind of events.

Example below shows bare minimum implementation to:

Start a new connection to remote host
Send HTTP GET request to remote host
Process received data in event and print number of received bytes

Client connection minimum example

#include "client.h"
#include "lwgsm/lwgsm.h"
#include "lwgsm/lwgsm_network_api.h"

/* Host parameter */
#define CONN_HOST           "example.com"
#define CONN_PORT           80

static lwgsmr_t   conn_callback_func(lwgsm_evt_t* evt);

/**
 * \brief           Request data for connection
 */
static const
uint8_t req_data[] = ""
                     "GET / HTTP/1.1\r\n"
                     "Host: " CONN_HOST "\r\n"
                     "Connection: close\r\n"
                     "\r\n";

/**
 * \brief           Start a new connection(s) as client
 */
void
client_connect(void) {
    lwgsmr_t res;

    /* Attach to GSM network */
    lwgsm_network_request_attach();

    /* Start a new connection as client in non-blocking mode */
    if ((res = lwgsm_conn_start(NULL, LWGSM_CONN_TYPE_TCP, "example.com", 80, NULL, conn_callback_func, 0)) == lwgsmOK) {
        printf("Connection to " CONN_HOST " started...\r\n");
    } else {
        printf("Cannot start connection to " CONN_HOST "!\r\n");
    }
}

/**
 * \brief           Event callback function for connection-only
 * \param[in]       evt: Event information with data
 * \return          \ref lwgsmOK on success, member of \ref lwgsmr_t otherwise
 */
static lwgsmr_t
conn_callback_func(lwgsm_evt_t* evt) {
    lwgsm_conn_p conn;
    lwgsmr_t res;
    uint8_t conn_num;

    conn = lwgsm_conn_get_from_evt(evt);          /* Get connection handle from event */
    if (conn == NULL) {
        return lwgsmERR;
    }
    conn_num = lwgsm_conn_getnum(conn);           /* Get connection number for identification */
    switch (lwgsm_evt_get_type(evt)) {
        case LWGSM_EVT_CONN_ACTIVE: {             /* Connection just active */
            printf("Connection %d active!\r\n", (int)conn_num);
            res = lwgsm_conn_send(conn, req_data, sizeof(req_data) - 1, NULL, 0); /* Start sending data in non-blocking mode */
            if (res == lwgsmOK) {
                printf("Sending request data to server...\r\n");
            } else {
                printf("Cannot send request data to server. Closing connection manually...\r\n");
                lwgsm_conn_close(conn, 0);        /* Close the connection */
            }
            break;
        }
        case LWGSM_EVT_CONN_CLOSE: {              /* Connection closed */
            if (lwgsm_evt_conn_close_is_forced(evt)) {
                printf("Connection %d closed by client!\r\n", (int)conn_num);
            } else {
                printf("Connection %d closed by remote side!\r\n", (int)conn_num);
            }
            break;
        }
        case LWGSM_EVT_CONN_SEND: {               /* Data send event */
            lwgsmr_t res = lwgsm_evt_conn_send_get_result(evt);
            if (res == lwgsmOK) {
                printf("Data sent successfully on connection %d...waiting to receive data from remote side...\r\n", (int)conn_num);
            } else {
                printf("Error while sending data on connection %d!\r\n", (int)conn_num);
            }
            break;
        }
        case LWGSM_EVT_CONN_RECV: {               /* Data received from remote side */
            lwgsm_pbuf_p pbuf = lwgsm_evt_conn_recv_get_buff(evt);
            lwgsm_conn_recved(conn, pbuf);        /* Notify stack about received pbuf */
            printf("Received %d bytes on connection %d..\r\n", (int)lwgsm_pbuf_length(pbuf, 1), (int)conn_num);
            break;
        }
        case LWGSM_EVT_CONN_ERROR: {              /* Error connecting to server */
            const char* host = lwgsm_evt_conn_error_get_host(evt);
            lwgsm_port_t port = lwgsm_evt_conn_error_get_port(evt);
            printf("Error connecting to %s:%d\r\n", host, (int)port);
            break;
        }
        default:
            break;
    }
    return lwgsmOK;
}

Sending data

Receiving data flow is always the same. Whenever new data packet arrives, corresponding event is called to notify application layer. When it comes to sending data, application may decide between 2 options (*this is valid only for non-UDP connections):

Write data to temporary transmit buffer
Execute send command for every API function call

Temporary transmit buffer

By calling lwgsm_conn_write() on active connection, temporary buffer is allocated and input data are copied to it. There is always up to 1 internal buffer active. When it is full (or if input data length is longer than maximal size), data are immediately send out and are not written to buffer.

GSM AT Firmware allows (current revision) to transmit up to 2048 bytes at a time with single command. When trying to send more than this, application would need to issue multiple send commands on AT commands level.

Write option is used mostly when application needs to write many different small chunks of data. Temporary buffer hence prevents many send command instructions as it is faster to send single command with big buffer, than many of them with smaller chunks of bytes.

Transmit packet manually

In some cases it is not possible to use temporary buffers, mostly because of memory constraints. Application can directly start send data instructions on AT level by using lwgsm_conn_send() or lwgsm_conn_sendto() functions.

group LWGSM_CONN

Connection API functions.

Typedefs

typedef struct lwgsm_conn *lwgsm_conn_p: Pointer to lwgsm_conn_t structure.

Enums

enum lwgsm_conn_type_t

List of possible connection types.

Values:

enumerator LWGSM_CONN_TYPE_TCP: Connection type is TCP

enumerator LWGSM_CONN_TYPE_UDP: Connection type is UDP

enumerator LWGSM_CONN_TYPE_SSL: Connection type is TCP over SSL

Functions

lwgsmr_t lwgsm_conn_start(lwgsm_conn_p *conn, lwgsm_conn_type_t type, const char *const host, lwgsm_port_t port, void *const arg, lwgsm_evt_fn conn_evt_fn, const uint32_t blocking)

Start a new connection of specific type.

Parameters

conn – [out] Pointer to connection handle to set new connection reference in case of successful connection
type – [in] Connection type. This parameter can be a value of lwgsm_conn_type_t enumeration
host – [in] Connection host. In case of IP, write it as string, ex. “192.168.1.1”
port – [in] Connection port
arg – [in] Pointer to user argument passed to connection if successfully connected
conn_evt_fn – [in] Callback function for this connection
blocking – [in] Status whether command should be blocking or not

Returns

lwgsmOK on success, member of lwgsmr_t enumeration otherwise

lwgsmr_t lwgsm_conn_close(lwgsm_conn_p conn, const uint32_t blocking)

Close specific or all connections.

Parameters

conn – [in] Connection handle to close. Set to NULL if you want to close all connections.
blocking – [in] Status whether command should be blocking or not

Returns

lwgsmOK on success, member of lwgsmr_t enumeration otherwise

lwgsmr_t lwgsm_conn_send(lwgsm_conn_p conn, const void *data, size_t btw, size_t *const bw, const uint32_t blocking)

Send data on already active connection either as client or server.

Parameters

conn – [in] Connection handle to send data
data – [in] Data to send
btw – [in] Number of bytes to send
bw – [out] Pointer to output variable to save number of sent data when successfully sent. Parameter value might not be accurate if you combine lwgsm_conn_write and lwgsm_conn_send functions
blocking – [in] Status whether command should be blocking or not

Returns

lwgsmOK on success, member of lwgsmr_t enumeration otherwise

lwgsmr_t lwgsm_conn_sendto(lwgsm_conn_p conn, const lwgsm_ip_t *const ip, lwgsm_port_t port, const void *data, size_t btw, size_t *bw, const uint32_t blocking)

Send data on active connection of type UDP to specific remote IP and port.

Note

In case IP and port values are not set, it will behave as normal send function (suitable for TCP too)

Parameters

conn – [in] Connection handle to send data
ip – [in] Remote IP address for UDP connection
port – [in] Remote port connection
data – [in] Pointer to data to send
btw – [in] Number of bytes to send
bw – [out] Pointer to output variable to save number of sent data when successfully sent
blocking – [in] Status whether command should be blocking or not

Returns

lwgsmOK on success, member of lwgsmr_t enumeration otherwise

lwgsmr_t lwgsm_conn_set_arg(lwgsm_conn_p conn, void *const arg)

Set argument variable for connection.