ARMmbed
/
mbed-os
mirror of https://github.com/ARMmbed/mbed-os.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Cellular: Updated coding guidelines

pull/6927/head
Ari Parkkila 2018-05-17 09:02:54 +03:00
parent a146e0e7ff
commit 6a3dce839e
7 changed files with 143 additions and 134 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

143
features/cellular/TESTS/socket/udp/main.cpp
View File

@ -71,7 +71,7 @@ void trace_release()
static char time_st[sizeof("[12345678]") + 1];
static char* trace_time(size_t ss)
static char *trace_time(size_t ss)
{
snprintf(time_st, sizeof("[12345678]"), "[%08llu]", rtos::Kernel::get_ms_count());
return time_st;
@ -80,7 +80,7 @@ static char* trace_time(size_t ss)
static void trace_open()
{
mbed_trace_init();
mbed_trace_prefix_function_set( &trace_time );
mbed_trace_prefix_function_set(&trace_time);
mbed_trace_mutex_wait_function_set(trace_wait);
mbed_trace_mutex_release_function_set(trace_release);
@ -104,60 +104,66 @@ static rtos::EventFlags eventFlags;
class EchoSocket : public UDPSocket {
public:
EchoSocket(int size) : UDPSocket(), _data(0), _size(size), _async_flag(0), _tx_pending(false), _rx_pending(false) {
}
virtual ~EchoSocket() {
delete _data;
}
void set_async(int async) {
_async_flag = async;
EchoSocket(int size) : UDPSocket(), _data(0), _size(size), _async_flag(0), _tx_pending(false), _rx_pending(false)
{
}
virtual ~EchoSocket()
{
delete _data;
}
void set_async(int async)
{
_async_flag = async;
if (_async_flag) {
set_blocking(false);
sigio(callback(this, &EchoSocket::async_callback));
}
}
}
void test_sendto(const char *const hostname = NULL) {
if (!_data) {
_data = new uint8_t[_size];
for (int i=0; i<_size; i++) {
_data[i] = (uint8_t)rand();
}
}
nsapi_size_or_error_t ret;
if (hostname) {
ret = sendto(hostname, ECHO_SERVER_UDP_PORT, _data, _size);
} else {
ret = sendto(echo_server_addr, _data, _size);
}
if (ret == _size) { // send successful
_tx_pending = false;
} else {
TEST_ASSERT(_async_flag && ret == NSAPI_ERROR_WOULD_BLOCK);
void test_sendto(const char *const hostname = NULL)
{
if (!_data) {
_data = new uint8_t[_size];
for (int i = 0; i < _size; i++) {
_data[i] = (uint8_t)rand();
}
}
nsapi_size_or_error_t ret;
if (hostname) {
ret = sendto(hostname, ECHO_SERVER_UDP_PORT, _data, _size);
} else {
ret = sendto(echo_server_addr, _data, _size);
}
if (ret == _size) { // send successful
_tx_pending = false;
} else {
TEST_ASSERT(_async_flag && ret == NSAPI_ERROR_WOULD_BLOCK);
_tx_pending = true;
}
}
}
}
void test_recvfrom() {
uint8_t *buf = new uint8_t[_size];
memset(buf, 0, _size);
SocketAddress recv_address;
nsapi_size_or_error_t ret = recvfrom(&recv_address, buf, _size);
if (ret == _size) { // recv successful
_rx_pending = false;
TEST_ASSERT(recv_address == echo_server_addr);
TEST_ASSERT(memcmp(_data, buf, _size) == 0);
delete _data;
_data = NULL;
_rx_pending = false;
} else {
TEST_ASSERT(_async_flag && ret == NSAPI_ERROR_WOULD_BLOCK);
void test_recvfrom()
{
uint8_t *buf = new uint8_t[_size];
memset(buf, 0, _size);
SocketAddress recv_address;
nsapi_size_or_error_t ret = recvfrom(&recv_address, buf, _size);
if (ret == _size) { // recv successful
_rx_pending = false;
TEST_ASSERT(recv_address == echo_server_addr);
TEST_ASSERT(memcmp(_data, buf, _size) == 0);
delete _data;
_data = NULL;
_rx_pending = false;
} else {
TEST_ASSERT(_async_flag && ret == NSAPI_ERROR_WOULD_BLOCK);
_rx_pending = true;
}
}
delete buf;
}
}
bool async_process() {
bool async_process()
{
if (_tx_pending) {
test_sendto();
}
@ -165,24 +171,25 @@ public:
test_recvfrom();
}
return _tx_pending | _rx_pending;
}
}
private:
void async_callback() {
eventFlags.set(_async_flag);
}
uint8_t *_data;
int _size;
uint32_t _async_flag; // 0 for blocking socket, signal bit for async
bool _tx_pending;
bool _rx_pending;
void async_callback()
{
eventFlags.set(_async_flag);
}
uint8_t *_data;
int _size;
uint32_t _async_flag; // 0 for blocking socket, signal bit for async
bool _tx_pending;
bool _rx_pending;
};
static void network_callback(nsapi_event_t ev, intptr_t ptr)
{
if (ev == NSAPI_EVENT_CONNECTION_STATUS_CHANGE) {
if (ptr == NSAPI_STATUS_GLOBAL_UP) {
MBED_ASSERT(network_semaphore.release() == osOK);
MBED_ASSERT(network_semaphore.release() == osOK);
}
}
}
@ -192,25 +199,25 @@ static void udp_network_stack()
cellular.set_serial(&cellular_serial);
TEST_ASSERT(cellular.init() == NSAPI_ERROR_OK);
#if defined (MDMRTS) && defined (MDMCTS)
cellular_serial.set_flow_control(SerialBase::RTSCTS, MDMRTS, MDMCTS);
cellular_serial.set_flow_control(SerialBase::RTSCTS, MDMRTS, MDMCTS);
#endif
cellular.attach(&network_callback);
TEST_ASSERT(cellular.start_dispatch() == NSAPI_ERROR_OK);
cellular.set_sim_pin(MBED_CONF_APP_CELLULAR_SIM_PIN);
#ifdef MBED_CONF_APP_APN
CellularNetwork * network = cellular.get_network();
CellularNetwork *network = cellular.get_network();
TEST_ASSERT(network->set_credentials(MBED_CONF_APP_APN) == NSAPI_ERROR_OK);
#endif
cellular_target_state = CellularConnectionFSM::STATE_CONNECTED;
TEST_ASSERT(cellular.continue_to_state(cellular_target_state) == NSAPI_ERROR_OK);
TEST_ASSERT(network_semaphore.wait(NETWORK_TIMEOUT) == 1);
TEST_ASSERT(network_semaphore.wait(NETWORK_TIMEOUT) == 1);
}
static void udp_gethostbyname()
{
TEST_ASSERT(cellular.get_network()->gethostbyname(ECHO_SERVER_NAME, &echo_server_addr) == 0);
tr_info("Echo server IP: %s", echo_server_addr.get_ip_address());
echo_server_addr.set_port(7);
echo_server_addr.set_port(7);
}
static void udp_socket_send_receive()
@ -250,21 +257,21 @@ static utest::v1::status_t greentea_failure_handler(const Case *const source, co
{
#if MBED_CONF_MBED_TRACE_ENABLE
trace_close();
#endif
#endif
greentea_case_failure_abort_handler(source, reason);
return STATUS_ABORT;
}
static Case cases[] = {
Case("UDP network stack", udp_network_stack, greentea_failure_handler),
Case("UDP gethostbyname", udp_gethostbyname, greentea_failure_handler),
Case("UDP socket send/receive", udp_socket_send_receive, greentea_failure_handler),
Case("UDP socket send/receive async", udp_socket_send_receive_async, greentea_failure_handler),
Case("UDP network stack", udp_network_stack, greentea_failure_handler),
Case("UDP gethostbyname", udp_gethostbyname, greentea_failure_handler),
Case("UDP socket send/receive", udp_socket_send_receive, greentea_failure_handler),
Case("UDP socket send/receive async", udp_socket_send_receive_async, greentea_failure_handler),
};
static utest::v1::status_t test_setup(const size_t number_of_cases)
{
GREENTEA_SETUP(10*60, "default_auto"); // network registration may take up to 180 seconds, DNS query a couple of minutes, etc.
GREENTEA_SETUP(10 * 60, "default_auto"); // network registration may take up to 180 seconds, DNS query a couple of minutes, etc.
return verbose_test_setup_handler(number_of_cases);
}
@ -278,6 +285,6 @@ int main()
int ret = Harness::run(specification);
#if MBED_CONF_MBED_TRACE_ENABLE
trace_close();
#endif
return ret;
#endif
return ret;
}

38
features/cellular/framework/AT/ATHandler.cpp
View File

@ -265,7 +265,7 @@ void ATHandler::set_at_timeout(uint32_t timeout_milliseconds, bool default_timeo
void ATHandler::restore_at_timeout()
{
if (_previous_at_timeout != _at_timeout) {
_at_timeout =_previous_at_timeout;
_at_timeout = _previous_at_timeout;
}
}
@ -332,7 +332,7 @@ int ATHandler::poll_timeout(bool wait_for_timeout)
uint64_t now = rtos::Kernel::get_ms_count();
if (now >= _start_time + _at_timeout) {
timeout = 0;
} else if ( _start_time + _at_timeout - now > INT_MAX) {
} else if (_start_time + _at_timeout - now > INT_MAX) {
timeout = INT_MAX;
} else {
timeout = _start_time + _at_timeout - now;
@ -455,7 +455,7 @@ ssize_t ATHandler::read(char *buf, size_t size, bool read_even_stop_tag, bool he
}
size_t match_pos = 0;
size_t read_size = hex ? size*2 : size;
size_t read_size = hex ? size * 2 : size;
consume_char('\"');
@ -465,7 +465,7 @@ ssize_t ATHandler::read(char *buf, size_t size, bool read_even_stop_tag, bool he
for (; read_idx < (read_size + match_pos); read_idx++) {
int c = get_char();
buf_idx = hex ? read_idx/2 : read_idx;
buf_idx = hex ? read_idx / 2 : read_idx;
if (c == -1) {
buf[buf_idx] = '\0';
set_error(NSAPI_ERROR_DEVICE_ERROR);
@ -496,7 +496,7 @@ ssize_t ATHandler::read(char *buf, size_t size, bool read_even_stop_tag, bool he
} else {
hexbuf[read_idx % 2] = c;
if (read_idx % 2 == 1) {
hex_str_to_char_str(hexbuf, 2, buf+buf_idx);
hex_str_to_char_str(hexbuf, 2, buf + buf_idx);
}
}
}
@ -540,7 +540,7 @@ void ATHandler::set_default_delimiter()
_delimiter = DEFAULT_DELIMITER;
}
void ATHandler::set_tag(tag_t* tag_dst, const char *tag_seq)
void ATHandler::set_tag(tag_t *tag_dst, const char *tag_seq)
{
if (tag_seq) {
size_t tag_len = strlen(tag_seq);
@ -589,7 +589,7 @@ void ATHandler::set_scope(ScopeType scope_type)
}
// should match from recv_pos?
bool ATHandler::match(const char* str, size_t size)
bool ATHandler::match(const char *str, size_t size)
{
rewind_buffer();
@ -685,7 +685,7 @@ void ATHandler::set_3gpp_error(int err, DeviceErrorType error_type)
// CMS errors 0-127 maps straight to 3GPP errors
_last_3gpp_error = err;
} else {
for (size_t i = 0; i<sizeof(map_3gpp_errors)/sizeof(map_3gpp_errors[0]); i++) {
for (size_t i = 0; i < sizeof(map_3gpp_errors) / sizeof(map_3gpp_errors[0]); i++) {
if (map_3gpp_errors[i][0] == err) {
_last_3gpp_error = map_3gpp_errors[i][1];
tr_debug("AT3GPP error code %d", get_3gpp_error());
@ -754,7 +754,7 @@ void ATHandler::resp(const char *prefix, bool check_urc)
} else {
// If no prefix, no CRLF and no more chance to match for OK, ERROR or URC(since max resp length is already in buffer)
// return so data could be read
if (!prefix && ((_recv_len-_recv_pos) >= _max_resp_length)) {
if (!prefix && ((_recv_len - _recv_pos) >= _max_resp_length)) {
return;
}
if (!fill_buffer()) {
@ -892,7 +892,7 @@ bool ATHandler::consume_to_stop_tag()
return true;
}
if (consume_to_tag((const char*)_stop_tag->tag, true)) {
if (consume_to_tag((const char *)_stop_tag->tag, true)) {
return true;
}
@ -954,19 +954,19 @@ void ATHandler::set_string(char *dest, const char *src, size_t src_len)
dest[src_len] = '\0';
}
const char* ATHandler::mem_str(const char* dest, size_t dest_len, const char* src, size_t src_len)
const char *ATHandler::mem_str(const char *dest, size_t dest_len, const char *src, size_t src_len)
{
if (dest_len > src_len) {
for(size_t i = 0; i < dest_len-src_len+1; ++i) {
if(memcmp(dest+i, src, src_len) == 0) {
return dest+i;
for(size_t i = 0; i < dest_len - src_len + 1; ++i) {
if(memcmp(dest + i, src, src_len) == 0) {
return dest + i;
}
}
}
return NULL;
}
void ATHandler::cmd_start(const char* cmd)
void ATHandler::cmd_start(const char *cmd)
{
if (_at_send_delay) {
@ -998,7 +998,7 @@ void ATHandler::write_int(int32_t param)
}
}
void ATHandler::write_string(const char* param, bool useQuotations)
void ATHandler::write_string(const char *param, bool useQuotations)
{
// do common checks before sending subparameter
if (check_cmd_send() == false) {
@ -1042,18 +1042,18 @@ size_t ATHandler::write(const void *data, size_t len)
fhs.fh = _fileHandle;
fhs.events = POLLOUT;
size_t write_len = 0;
for (; write_len < len; ) {
for (; write_len < len;) {
int count = poll(&fhs, 1, poll_timeout());
if (count <= 0 || !(fhs.revents & POLLOUT)) {
set_error(NSAPI_ERROR_DEVICE_ERROR);
return 0;
}
ssize_t ret = _fileHandle->write((uint8_t*)data + write_len, len - write_len);
ssize_t ret = _fileHandle->write((uint8_t *)data + write_len, len - write_len);
if (ret < 0) {
set_error(NSAPI_ERROR_DEVICE_ERROR);
return 0;
}
debug_print((char*)data + write_len, ret);
debug_print((char *)data + write_len, ret);
write_len += (size_t)ret;
}

16
features/cellular/framework/AT/ATHandler.h
View File

@ -28,8 +28,7 @@
#include "Callback.h"
#include "EventQueue.h"
namespace mbed
{
namespace mbed {
class FileHandle;
@ -64,8 +63,7 @@ struct device_err_t {
*
* Class for sending AT commands and parsing AT responses.
*/
class ATHandler
{
class ATHandler {
public:
/** Constructor
@ -220,7 +218,7 @@ public:
*
* @param cmd AT command to be written to modem
*/
void cmd_start(const char* cmd);
void cmd_start(const char *cmd);
/** Writes integer type AT command subparameter. Starts with the delimiter if not the first param after cmd_start.
* In case of failure when writing, the last error is set to NSAPI_ERROR_DEVICE_ERROR.
@ -236,7 +234,7 @@ public:
* @param param string to be written to modem as AT command subparameter
* @param useQuotations flag indicating whether the string should be included in quotation marks
*/
void write_string(const char* param, bool useQuotations = true);
void write_string(const char *param, bool useQuotations = true);
/** Stops the AT command by writing command-line terminator CR to mark command as finished.
*/
@ -444,10 +442,10 @@ private:
// Returns true on successful read OR false on timeout.
bool fill_buffer(bool wait_for_timeout = true);
void set_tag(tag_t* tag_dest, const char *tag_seq);
void set_tag(tag_t *tag_dest, const char *tag_seq);
// Rewinds the receiving buffer and compares it against given str.
bool match(const char* str, size_t size);
bool match(const char *str, size_t size);
// Iterates URCs and checks if they match the receiving buffer content.
// If URC match sets the scope to information response and after urc's cb returns
// finishes the information response scope(consumes to CRLF).
@ -501,7 +499,7 @@ private:
*
* @return pointer to first occurrence of src in dest
*/
const char* mem_str(const char* dest, size_t dest_len, const char* src, size_t src_len);
const char *mem_str(const char *dest, size_t dest_len, const char *src, size_t src_len);
// check is urc is already added
bool find_urc_handler(const char *prefix, mbed::Callback<void()> callback);

6
features/cellular/framework/AT/AT_CellularDevice.cpp
View File

@ -45,7 +45,7 @@ AT_CellularDevice::~AT_CellularDevice()
}
// each parser is associated with one filehandle (that is UART)
ATHandler* AT_CellularDevice::get_at_handler(FileHandle *fileHandle)
ATHandler *AT_CellularDevice::get_at_handler(FileHandle *fileHandle)
{
if (!fileHandle) {
return NULL;
@ -71,7 +71,7 @@ ATHandler* AT_CellularDevice::get_at_handler(FileHandle *fileHandle)
return atHandler;
}
void AT_CellularDevice::release_at_handler(ATHandler* at_handler)
void AT_CellularDevice::release_at_handler(ATHandler *at_handler)
{
if (!at_handler) {
return;
@ -92,7 +92,7 @@ void AT_CellularDevice::release_at_handler(ATHandler* at_handler)
break;
} else {
prev = atHandler;
atHandler =atHandler->_nextATHandler;
atHandler = atHandler->_nextATHandler;
}
}
}

58
features/cellular/framework/AT/AT_CellularNetwork.cpp
View File

@ -168,27 +168,27 @@ nsapi_error_t AT_CellularNetwork::set_credentials(const char *apn,
{
size_t len;
if (apn && (len = strlen(apn)) > 0) {
_apn = (char*)malloc(len*sizeof(char)+1);
_apn = (char *)malloc(len * sizeof(char) + 1);
if (_apn) {
memcpy(_apn, apn, len+1);
memcpy(_apn, apn, len + 1);
} else {
return NSAPI_ERROR_NO_MEMORY;
}
}
if (username && (len = strlen(username)) > 0) {
_uname = (char*)malloc(len*sizeof(char)+1);
_uname = (char *)malloc(len * sizeof(char) + 1);
if (_uname) {
memcpy(_uname, username, len+1);
memcpy(_uname, username, len + 1);
} else {
return NSAPI_ERROR_NO_MEMORY;
}
}
if (password && (len = strlen(password)) > 0) {
_pwd = (char*)malloc(len*sizeof(char)+1);
_pwd = (char *)malloc(len * sizeof(char) + 1);
if (_pwd) {
memcpy(_pwd, password, len+1);
memcpy(_pwd, password, len + 1);
} else {
return NSAPI_ERROR_NO_MEMORY;
}
@ -277,7 +277,7 @@ nsapi_error_t AT_CellularNetwork::activate_context()
_at.resp_stop();
if (!_is_context_active) {
tr_info("Activate PDP context %d",_cid);
tr_info("Activate PDP context %d", _cid);
_at.cmd_start("AT+CGACT=1,");
_at.write_int(_cid);
_at.cmd_stop();
@ -462,7 +462,7 @@ bool AT_CellularNetwork::set_new_context(int cid)
}
}
char pdp_type[8+1] = {0};
char pdp_type[8 + 1] = {0};
switch (tmp_stack) {
case IPV4_STACK:
@ -541,7 +541,7 @@ bool AT_CellularNetwork::get_context()
if (pdp_type_len > 0) {
apn_len = _at.read_string(apn, sizeof(apn) - 1);
if (apn_len >= 0) {
if (_apn && (strcmp(apn, _apn) != 0) ) {
if (_apn && (strcmp(apn, _apn) != 0)) {
continue;
}
nsapi_ip_stack_t pdp_stack = string_to_stack_type(pdp_type_from_context);
@ -571,7 +571,7 @@ bool AT_CellularNetwork::get_context()
_cid = cid;
break;
}
// If PDP is IPV4 or IPV6 they are already checked if supported
// If PDP is IPV4 or IPV6 they are already checked if supported
} else {
_ip_stack_type = pdp_stack;
_cid = cid;
@ -590,16 +590,16 @@ bool AT_CellularNetwork::get_context()
}
_at.resp_stop();
if (_cid == -1) { // no suitable context was found so create a new one
if (!set_new_context(cid_max+1)) {
if (!set_new_context(cid_max + 1)) {
return false;
}
}
// save the apn
if (apn_len > 0 && !_apn) {
_apn = (char*)malloc(apn_len*sizeof(char)+1);
_apn = (char *)malloc(apn_len * sizeof(char) + 1);
if (_apn) {
memcpy(_apn, apn, apn_len+1);
memcpy(_apn, apn, apn_len + 1);
} else {
return false;
}
@ -609,7 +609,7 @@ bool AT_CellularNetwork::get_context()
return true;
}
nsapi_ip_stack_t AT_CellularNetwork::string_to_stack_type(const char* pdp_type)
nsapi_ip_stack_t AT_CellularNetwork::string_to_stack_type(const char *pdp_type)
{
nsapi_ip_stack_t stack = DEFAULT_STACK;
int len = strlen(pdp_type);
@ -649,7 +649,7 @@ nsapi_error_t AT_CellularNetwork::set_registration_urc(RegistrationType type, bo
}
}
nsapi_error_t AT_CellularNetwork::get_network_registering_mode(NWRegisteringMode& mode)
nsapi_error_t AT_CellularNetwork::get_network_registering_mode(NWRegisteringMode &mode)
{
_at.lock();
_at.cmd_start("AT+COPS?");
@ -700,12 +700,12 @@ void AT_CellularNetwork::read_reg_params(RegistrationType type, RegistrationStat
reg_status = (RegistrationStatus)_at.read_int();
int len = _at.read_string(lac_string, LAC_LENGTH);
if (memcmp(lac_string, "ffff", LAC_LENGTH-1) && len >= 0) {
if (memcmp(lac_string, "ffff", LAC_LENGTH - 1) && len >= 0) {
lac_read = true;
}
len = _at.read_string(cell_id_string, CELL_ID_LENGTH);
if (memcmp(cell_id_string, "ffffffff", CELL_ID_LENGTH-1) && len >= 0) {
if (memcmp(cell_id_string, "ffffffff", CELL_ID_LENGTH - 1) && len >= 0) {
cell_id_read = true;
}
@ -713,12 +713,12 @@ void AT_CellularNetwork::read_reg_params(RegistrationType type, RegistrationStat
if (lac_read) {
lac = hex_str_to_int(lac_string, LAC_LENGTH);
tr_debug("lac %s %d", lac_string, lac );
tr_debug("lac %s %d", lac_string, lac);
}
if (cell_id_read) {
cell_id = hex_str_to_int(cell_id_string, CELL_ID_LENGTH);
tr_debug("cell_id %s %d", cell_id_string, cell_id );
tr_debug("cell_id %s %d", cell_id_string, cell_id);
}
}
@ -892,7 +892,7 @@ nsapi_error_t AT_CellularNetwork::set_access_technology_impl(RadioAccessTechnolo
return NSAPI_ERROR_UNSUPPORTED;
}
nsapi_error_t AT_CellularNetwork::get_access_technology(RadioAccessTechnology& rat)
nsapi_error_t AT_CellularNetwork::get_access_technology(RadioAccessTechnology &rat)
{
rat = _current_act;
return NSAPI_ERROR_OK;
@ -942,7 +942,7 @@ nsapi_error_t AT_CellularNetwork::scan_plmn(operList_t &operators, int &opsCount
// Optional - try read an int
ret = _at.read_int();
op->op_rat = (ret == error_code) ? RAT_UNKNOWN:(RadioAccessTechnology)ret;
op->op_rat = (ret == error_code) ? RAT_UNKNOWN : (RadioAccessTechnology)ret;
if ((_op_act == RAT_UNKNOWN) ||
((op->op_rat != RAT_UNKNOWN) && (op->op_rat == _op_act))) {
@ -975,8 +975,8 @@ nsapi_error_t AT_CellularNetwork::set_ciot_optimization_config(Supported_UE_Opt
return _at.unlock_return_error();
}
nsapi_error_t AT_CellularNetwork::get_ciot_optimization_config(Supported_UE_Opt& supported_opt,
Preferred_UE_Opt& preferred_opt)
nsapi_error_t AT_CellularNetwork::get_ciot_optimization_config(Supported_UE_Opt &supported_opt,
Preferred_UE_Opt &preferred_opt)
{
_at.lock();
@ -1013,7 +1013,7 @@ nsapi_error_t AT_CellularNetwork::get_rate_control(
int next_element = _at.read_int();
if (next_element >= 0) {
reports = (RateControlExceptionReports)next_element;
tr_debug("reports %d",reports);
tr_debug("reports %d", reports);
next_element = _at.read_int();
} else {
comma_found = false;
@ -1021,7 +1021,7 @@ nsapi_error_t AT_CellularNetwork::get_rate_control(
if (comma_found && next_element >= 0) {
timeUnit = (RateControlUplinkTimeUnit)next_element;
tr_debug("time %d",timeUnit);
tr_debug("time %d", timeUnit);
next_element = _at.read_int();
} else {
comma_found = false;
@ -1029,7 +1029,7 @@ nsapi_error_t AT_CellularNetwork::get_rate_control(
if (comma_found && next_element >= 0) {
uplinkRate = next_element;
tr_debug("rate %d",uplinkRate);
tr_debug("rate %d", uplinkRate);
}
}
_at.resp_stop();
@ -1039,16 +1039,16 @@ nsapi_error_t AT_CellularNetwork::get_rate_control(
return (ret == NSAPI_ERROR_OK) ? NSAPI_ERROR_OK : NSAPI_ERROR_PARAMETER;
}
nsapi_error_t AT_CellularNetwork::get_pdpcontext_params(pdpContextList_t& params_list)
nsapi_error_t AT_CellularNetwork::get_pdpcontext_params(pdpContextList_t &params_list)
{
const int ipv6_subnet_size = 128;
const int max_ipv6_size = 64;
char* ipv6_and_subnetmask = (char*)malloc(ipv6_subnet_size);
char *ipv6_and_subnetmask = (char *)malloc(ipv6_subnet_size);
if (!ipv6_and_subnetmask) {
return NSAPI_ERROR_NO_MEMORY;
}
char* temp = (char*)malloc(max_ipv6_size);
char *temp = (char *)malloc(max_ipv6_size);
if (!temp) {
free(ipv6_and_subnetmask);
return NSAPI_ERROR_NO_MEMORY;

4
features/cellular/framework/AT/AT_CellularSIM.cpp
View File

@ -38,7 +38,7 @@ nsapi_error_t AT_CellularSIM::get_sim_state(SimState &state)
_at.cmd_start("AT+CPIN?");
_at.cmd_stop();
_at.resp_start("+CPIN:");
ssize_t len = _at.read_string(simstr, sizeof (simstr));
ssize_t len = _at.read_string(simstr, sizeof(simstr));
if (len != -1) {
if (len >= 5 && memcmp(simstr, "READY", 5) == 0) {
state = SimStateReady;
@ -134,7 +134,7 @@ nsapi_error_t AT_CellularSIM::set_pin_query(const char *sim_pin, bool query_pin)
return _at.unlock_return_error();
}
nsapi_error_t AT_CellularSIM::get_imsi(char* imsi)
nsapi_error_t AT_CellularSIM::get_imsi(char *imsi)
{
_at.lock();
_at.cmd_start("AT+CIMI");

12
features/cellular/framework/common/CellularLog.cpp
View File

@ -31,22 +31,26 @@ static trace_t m_trace = {
.mutex_release_f = 0,
};
void mutex_wait_function_set(void (*mutex_wait_f)(void)) {
void mutex_wait_function_set(void (*mutex_wait_f)(void))
{
m_trace.mutex_wait_f = mutex_wait_f;
}
void mutex_release_function_set(void (*mutex_release_f)(void)) {
void mutex_release_function_set(void (*mutex_release_f)(void))
{
m_trace.mutex_release_f = mutex_release_f;
}
void mutex_wait() {
void mutex_wait()
{
if (m_trace.mutex_wait_f) {
m_trace.mutex_wait_f();
}
}
void mutex_release() {
void mutex_release()
{
if (m_trace.mutex_release_f) {
m_trace.mutex_release_f();
}