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

Cellular logging to use mbed_trace

pull/6082/head
Ari Parkkila 2018-02-19 12:44:24 +02:00
parent 331a27df63
commit f2613a6154
19 changed files with 144 additions and 264 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
features/cellular/TESTS/cellular/cellular_all/network.cpp
View File

@ -21,39 +21,39 @@ using namespace mbed;
static bool wait_register() static bool wait_register()
{ {
log_info("Try registering to network..."); tr_info("Try registering to network...");
if (network->set_registration() != NSAPI_ERROR_OK) { if (network->set_registration() != NSAPI_ERROR_OK) {
log_error("Network registration request failed."); tr_error("Network registration request failed.");
return false; return false;
} }
CellularNetwork::RegistrationStatus status; CellularNetwork::RegistrationStatus status;
for (int i=0; i<180; i++) { for (int i=0; i<180; i++) {
log_info("Register to network %d...", i); tr_info("Register to network %d...", i);
for (int type = 0; type < CellularNetwork::C_MAX; type++) { for (int type = 0; type < CellularNetwork::C_MAX; type++) {
if (network->get_registration_status((CellularNetwork::RegistrationType)type, status) == NSAPI_ERROR_OK) { if (network->get_registration_status((CellularNetwork::RegistrationType)type, status) == NSAPI_ERROR_OK) {
log_info("status %d...", status); tr_info("status %d...", status);
switch (status) { switch (status) {
case CellularNetwork::RegisteredRoaming: case CellularNetwork::RegisteredRoaming:
// fall-through // fall-through
case CellularNetwork::RegisteredHomeNetwork: case CellularNetwork::RegisteredHomeNetwork:
log_info("Registered to network."); tr_info("Registered to network.");
return true; return true;
case CellularNetwork::RegisteredSMSOnlyRoaming: case CellularNetwork::RegisteredSMSOnlyRoaming:
// fall-through // fall-through
case CellularNetwork::RegisteredSMSOnlyHome: case CellularNetwork::RegisteredSMSOnlyHome:
log_warn("SMS only network registration!"); tr_warn("SMS only network registration!");
return true; return true;
case CellularNetwork::RegisteredCSFBNotPreferredRoaming: case CellularNetwork::RegisteredCSFBNotPreferredRoaming:
// fall-through // fall-through
case CellularNetwork::RegisteredCSFBNotPreferredHome: case CellularNetwork::RegisteredCSFBNotPreferredHome:
log_warn("Not preferred network registration!"); tr_warn("Not preferred network registration!");
return true; return true;
case CellularNetwork::AttachedEmergencyOnly: case CellularNetwork::AttachedEmergencyOnly:
log_warn("Emergency only network registration!"); tr_warn("Emergency only network registration!");
return true; return true;
case CellularNetwork::RegistrationDenied: case CellularNetwork::RegistrationDenied:
log_warn("Network registration denied!"); tr_warn("Network registration denied!");
wait(i); wait(i);
break; break;
case CellularNetwork::NotRegistered: case CellularNetwork::NotRegistered:
@ -71,9 +71,9 @@ static bool wait_register()
void test_attach() void test_attach()
{ {
log_info("Register to network."); tr_info("Register to network.");
TEST_ASSERT(wait_register()); TEST_ASSERT(wait_register());
log_info("Attach to network."); tr_info("Attach to network.");
nsapi_error_t err = network->set_attach(); nsapi_error_t err = network->set_attach();
TEST_ASSERT(!err); TEST_ASSERT(!err);
CellularNetwork::AttachStatus status; CellularNetwork::AttachStatus status;
@ -91,7 +91,7 @@ void test_get_ip_address()
{ {
const char *ip = network->get_ip_address(); const char *ip = network->get_ip_address();
TEST_ASSERT(ip && ip[0]); TEST_ASSERT(ip && ip[0]);
log_info("IP: %s\r\n", ip); tr_info("IP: %s\r\n", ip);
} }
void test_disconnect() void test_disconnect()

4
features/cellular/TESTS/cellular/cellular_all/power.cpp
View File

@ -30,7 +30,7 @@ static bool start_cellular_at(CellularPower *pwr)
if (err != NSAPI_ERROR_OK && err != NSAPI_ERROR_UNSUPPORTED) { if (err != NSAPI_ERROR_OK && err != NSAPI_ERROR_UNSUPPORTED) {
return false; return false;
} }
log_info("Wait for cellular device 180 seconds..."); tr_info("Wait for cellular device 180 seconds...");
for (int i = 0; i < 180; i++) { for (int i = 0; i < 180; i++) {
if (pwr->set_at_mode() == NSAPI_ERROR_OK) { if (pwr->set_at_mode() == NSAPI_ERROR_OK) {
return true; return true;
@ -44,7 +44,7 @@ void test_create_power()
{ {
TEST_ASSERT(start_cellular_at(pwr)); TEST_ASSERT(start_cellular_at(pwr));
log_info("Cellular device is ready!"); tr_info("Cellular device is ready!");
} }
// TODO: tests still missing for off, sleep, opt_power_save_mode, opt_receive_period // TODO: tests still missing for off, sleep, opt_power_save_mode, opt_receive_period

2
features/cellular/TESTS/cellular/cellular_all/sim.cpp
View File

@ -26,7 +26,7 @@ void test_get_sim_state()
{ {
wait(1); wait(1);
CellularSIM::SimState state = CellularSIM::SimStateUnknown; CellularSIM::SimState state = CellularSIM::SimStateUnknown;
log_info("Wait SIM for 180 seconds..."); tr_info("Wait SIM for 180 seconds...");
for (int i = 0; i < 180; i++) { for (int i = 0; i < 180; i++) {
CellularSIM::SimState tmp_state; CellularSIM::SimState tmp_state;
if ((sim->get_sim_state(tmp_state) == NSAPI_ERROR_OK) && tmp_state != CellularSIM::SimStateUnknown) { if ((sim->get_sim_state(tmp_state) == NSAPI_ERROR_OK) && tmp_state != CellularSIM::SimStateUnknown) {

4
features/cellular/TESTS/cellular/cellular_all/stack.cpp
View File

@ -54,7 +54,7 @@ void test_socket_send_receive_blocking()
// Send to echo server // Send to echo server
while (send_tries <= max_send_tries) { while (send_tries <= max_send_tries) {
log_info("ONE!!!"); tr_info("ONE!!!");
send_count = socket.sendto(SERVER_IP_ADDR, SERVER_UDP_PORT, send_buffer, sizeof(send_buffer)); send_count = socket.sendto(SERVER_IP_ADDR, SERVER_UDP_PORT, send_buffer, sizeof(send_buffer));
TEST_ASSERT_MESSAGE(send_count == sizeof(send_buffer), "Sent count doesnt match sent buffer!"); TEST_ASSERT_MESSAGE(send_count == sizeof(send_buffer), "Sent count doesnt match sent buffer!");
send_tries++; send_tries++;
@ -65,7 +65,7 @@ void test_socket_send_receive_blocking()
// 2 tries. First recv attempt should be blocked and wait for a max 5 seconds for socket read flag // 2 tries. First recv attempt should be blocked and wait for a max 5 seconds for socket read flag
int recv_tries = 2; int recv_tries = 2;
while (recv_tries >= 0) { while (recv_tries >= 0) {
log_info("RECV!!!"); tr_info("RECV!!!");
receive_count = socket.recvfrom(&address, receive_buffer, sizeof(receive_buffer)); receive_count = socket.recvfrom(&address, receive_buffer, sizeof(receive_buffer));
if (receive_count > 0) { if (receive_count > 0) {
break; break;

2
features/cellular/UNITTESTS/at/at_cellularnetwork/test_at_cellularnetwork.cpp
View File

@ -28,8 +28,6 @@
using namespace mbed; using namespace mbed;
using namespace events; using namespace events;
uint32_t mbed::cellular_log_time = 0;
void conn_stat_cb(nsapi_error_t error) void conn_stat_cb(nsapi_error_t error)
{ {

2
features/cellular/UNITTESTS/at/at_cellularsim/test_at_cellularsim.cpp
View File

@ -28,8 +28,6 @@
using namespace mbed; using namespace mbed;
using namespace events; using namespace events;
uint32_t mbed::cellular_log_time = 0;
Test_AT_CellularSIM::Test_AT_CellularSIM() Test_AT_CellularSIM::Test_AT_CellularSIM()
{ {
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK;

2
features/cellular/UNITTESTS/at/at_cellularsms/test_at_cellularsms.cpp
View File

@ -28,8 +28,6 @@
using namespace mbed; using namespace mbed;
using namespace events; using namespace events;
uint32_t mbed::cellular_log_time = 0;
Test_AT_CellularSMS::Test_AT_CellularSMS() Test_AT_CellularSMS::Test_AT_CellularSMS()
{ {
ATHandler_stub::return_given_size = false; ATHandler_stub::return_given_size = false;

2
features/cellular/UNITTESTS/at/at_cellularstack/test_at_cellularstack.cpp
View File

@ -29,8 +29,6 @@
using namespace mbed; using namespace mbed;
using namespace events; using namespace events;
uint32_t mbed::cellular_log_time = 0;
class MyStack : public AT_CellularStack { class MyStack : public AT_CellularStack {
public: public:
bool bool_value; bool bool_value;

2
features/cellular/UNITTESTS/at/athandler/test_athandler.cpp
View File

@ -30,8 +30,6 @@
using namespace mbed; using namespace mbed;
using namespace events; using namespace events;
uint32_t mbed::cellular_log_time = 0;
void urc_callback() void urc_callback()
{ {
} }

88
features/cellular/easy_cellular/CellularConnectionUtil.cpp
View File

@ -62,7 +62,7 @@ nsapi_error_t CellularConnectionUtil::init()
at_queue.chain(&_queue); at_queue.chain(&_queue);
log_info("init done..."); tr_info("init done...");
return NSAPI_ERROR_OK; return NSAPI_ERROR_OK;
} }
@ -77,10 +77,10 @@ bool CellularConnectionUtil::open_power(FileHandle *fh)
nsapi_error_t err = _power->on(); nsapi_error_t err = _power->on();
if (err != NSAPI_ERROR_OK && err != NSAPI_ERROR_UNSUPPORTED) { if (err != NSAPI_ERROR_OK && err != NSAPI_ERROR_UNSUPPORTED) {
log_warn("Cellular start failed. Power off/on."); tr_warn("Cellular start failed. Power off/on.");
err = _power->off(); err = _power->off();
if (err != NSAPI_ERROR_OK && err != NSAPI_ERROR_UNSUPPORTED) { if (err != NSAPI_ERROR_OK && err != NSAPI_ERROR_UNSUPPORTED) {
log_error("Cellular power down failed!"); tr_error("Cellular power down failed!");
} }
return false; return false;
} }
@ -107,14 +107,14 @@ bool CellularConnectionUtil::open_sim()
// wait until SIM is readable // wait until SIM is readable
// here you could add wait(secs) if you know start delay of your SIM // here you could add wait(secs) if you know start delay of your SIM
while (sim->get_sim_state(state) != NSAPI_ERROR_OK || state == CellularSIM::SimStateUnknown) { while (sim->get_sim_state(state) != NSAPI_ERROR_OK || state == CellularSIM::SimStateUnknown) {
log_debug("Waiting for SIM (state %d)...", state); tr_debug("Waiting for SIM (state %d)...", state);
return false; return false;
} }
if (state == CellularSIM::SimStatePinNeeded) { if (state == CellularSIM::SimStatePinNeeded) {
log_info("SIM pin required, entering pin: %s", _sim_pin); tr_info("SIM pin required, entering pin: %s", _sim_pin);
err = sim->set_pin(_sim_pin); err = sim->set_pin(_sim_pin);
if (err) { if (err) {
log_error("SIM pin set failed with: %d, bailing out...", err); tr_error("SIM pin set failed with: %d, bailing out...", err);
return false; return false;
} }
// here you could add wait(secs) if you know delay of changing PIN on your SIM // here you could add wait(secs) if you know delay of changing PIN on your SIM
@ -122,13 +122,13 @@ bool CellularConnectionUtil::open_sim()
if (sim->get_sim_state(state) == NSAPI_ERROR_OK && state == CellularSIM::SimStateReady) { if (sim->get_sim_state(state) == NSAPI_ERROR_OK && state == CellularSIM::SimStateReady) {
break; break;
} }
log_debug("SIM state: %d", state); tr_debug("SIM state: %d", state);
return false; return false;
} }
} }
return state == CellularSIM::SimStateReady; return state == CellularSIM::SimStateReady;
} else { } else {
log_info("Continue without SIM."); tr_info("Continue without SIM.");
return true; return true;
} }
} }
@ -138,13 +138,13 @@ void CellularConnectionUtil::device_ready()
CellularInformation *info = _cellularDevice->open_information(_serial); CellularInformation *info = _cellularDevice->open_information(_serial);
if (info->get_manufacturer(device_info_buf, sizeof(device_info_buf)) == NSAPI_ERROR_OK) { if (info->get_manufacturer(device_info_buf, sizeof(device_info_buf)) == NSAPI_ERROR_OK) {
log_info("Cellular device manufacturer: %s", device_info_buf); tr_info("Cellular device manufacturer: %s", device_info_buf);
} }
if (info->get_model(device_info_buf, sizeof(device_info_buf)) == NSAPI_ERROR_OK) { if (info->get_model(device_info_buf, sizeof(device_info_buf)) == NSAPI_ERROR_OK) {
log_info("Cellular device model: %s", device_info_buf); tr_info("Cellular device model: %s", device_info_buf);
} }
if (info->get_revision(device_info_buf, sizeof(device_info_buf)) == NSAPI_ERROR_OK) { if (info->get_revision(device_info_buf, sizeof(device_info_buf)) == NSAPI_ERROR_OK) {
log_info("Cellular device revision: %s", device_info_buf); tr_info("Cellular device revision: %s", device_info_buf);
} }
} }
@ -159,7 +159,7 @@ bool CellularConnectionUtil::open_network()
bool CellularConnectionUtil::set_network_registration(char *plmn) bool CellularConnectionUtil::set_network_registration(char *plmn)
{ {
if (_network->set_registration(plmn) != NSAPI_ERROR_OK) { if (_network->set_registration(plmn) != NSAPI_ERROR_OK) {
log_error("Failed to set network registration."); tr_error("Failed to set network registration.");
return false; return false;
} }
return true; return true;
@ -173,7 +173,7 @@ bool CellularConnectionUtil::get_network_registration(CellularNetwork::Registrat
nsapi_error_t err = _network->get_registration_status(type, status); nsapi_error_t err = _network->get_registration_status(type, status);
if (err != NSAPI_ERROR_OK) { if (err != NSAPI_ERROR_OK) {
if (err != NSAPI_ERROR_UNSUPPORTED) { if (err != NSAPI_ERROR_UNSUPPORTED) {
log_warn("Get network registration failed (type %d)!", type); tr_warn("Get network registration failed (type %d)!", type);
} }
return false; return false;
} }
@ -188,16 +188,16 @@ bool CellularConnectionUtil::get_network_registration(CellularNetwork::Registrat
is_roaming = true; is_roaming = true;
// fall-through // fall-through
case CellularNetwork::RegisteredSMSOnlyHome: case CellularNetwork::RegisteredSMSOnlyHome:
log_warn("SMS only network registration!"); tr_warn("SMS only network registration!");
break; break;
case CellularNetwork::RegisteredCSFBNotPreferredRoaming: case CellularNetwork::RegisteredCSFBNotPreferredRoaming:
is_roaming = true; is_roaming = true;
// fall-through // fall-through
case CellularNetwork::RegisteredCSFBNotPreferredHome: case CellularNetwork::RegisteredCSFBNotPreferredHome:
log_warn("Not preferred network registration!"); tr_warn("Not preferred network registration!");
break; break;
case CellularNetwork::AttachedEmergencyOnly: case CellularNetwork::AttachedEmergencyOnly:
log_warn("Emergency only network registration!"); tr_warn("Emergency only network registration!");
break; break;
case CellularNetwork::RegistrationDenied: case CellularNetwork::RegistrationDenied:
case CellularNetwork::NotRegistered: case CellularNetwork::NotRegistered:
@ -208,7 +208,7 @@ bool CellularConnectionUtil::get_network_registration(CellularNetwork::Registrat
} }
if (is_roaming) { if (is_roaming) {
log_warn("Roaming cellular network!"); tr_warn("Roaming cellular network!");
} }
return true; return true;
@ -234,7 +234,7 @@ bool CellularConnectionUtil::set_attach_network()
void CellularConnectionUtil::report_failure(const char* msg) void CellularConnectionUtil::report_failure(const char* msg)
{ {
log_error("Cellular network failed: %s", msg); tr_error("Cellular network failed: %s", msg);
if (_status_callback) { if (_status_callback) {
_status_callback(_state, _next_state); _status_callback(_state, _next_state);
} }
@ -261,13 +261,13 @@ void CellularConnectionUtil::event()
switch (_state) { switch (_state) {
case STATE_POWER_ON: case STATE_POWER_ON:
cellularDevice.set_timeout(TIMEOUT_POWER_ON); cellularDevice.set_timeout(TIMEOUT_POWER_ON);
log_info("Cellular power ON (timeout %d ms)", TIMEOUT_POWER_ON); tr_info("Cellular power ON (timeout %d ms)", TIMEOUT_POWER_ON);
if (open_power(_serial)) { if (open_power(_serial)) {
_next_state = STATE_DEVICE_READY; _next_state = STATE_DEVICE_READY;
} else { } else {
static int retry_count; static int retry_count;
if (++retry_count <= 10) { if (++retry_count <= 10) {
log_warn("Power ON retry %d", retry_count); tr_warn("Power ON retry %d", retry_count);
event_timeout = 1000; event_timeout = 1000;
} else { } else {
report_failure("Power"); report_failure("Power");
@ -278,12 +278,12 @@ void CellularConnectionUtil::event()
case STATE_DEVICE_READY: case STATE_DEVICE_READY:
cellularDevice.set_timeout(TIMEOUT_POWER_ON); cellularDevice.set_timeout(TIMEOUT_POWER_ON);
if (_power->set_at_mode() == NSAPI_ERROR_OK) { if (_power->set_at_mode() == NSAPI_ERROR_OK) {
log_info("Cellular device ready"); tr_info("Cellular device ready");
_next_state = STATE_START_CELLULAR; _next_state = STATE_START_CELLULAR;
device_ready(); device_ready();
} else { } else {
static int retry_count = 0; static int retry_count = 0;
log_info("Waiting for cellular device (retry %d/10, timeout %d ms)", retry_count, TIMEOUT_POWER_ON); tr_info("Waiting for cellular device (retry %d/10, timeout %d ms)", retry_count, TIMEOUT_POWER_ON);
if (++retry_count <= 10) { if (++retry_count <= 10) {
event_timeout = 1000; event_timeout = 1000;
} else { } else {
@ -294,20 +294,20 @@ void CellularConnectionUtil::event()
break; break;
case STATE_START_CELLULAR: case STATE_START_CELLULAR:
cellularDevice.set_timeout(TIMEOUT_NETWORK); cellularDevice.set_timeout(TIMEOUT_NETWORK);
log_info("Start cellular (timeout %d ms)", TIMEOUT_NETWORK); tr_info("Start cellular (timeout %d ms)", TIMEOUT_NETWORK);
open_network(); open_network();
_next_state = STATE_SIM_PIN; _next_state = STATE_SIM_PIN;
break; break;
case STATE_SIM_PIN: case STATE_SIM_PIN:
cellularDevice.set_timeout(TIMEOUT_SIM_PIN); cellularDevice.set_timeout(TIMEOUT_SIM_PIN);
log_info("Start cellular (timeout %d ms)", TIMEOUT_SIM_PIN); tr_info("Start cellular (timeout %d ms)", TIMEOUT_SIM_PIN);
if (open_sim()) { if (open_sim()) {
_next_state = STATE_REGISTERING_NETWORK; _next_state = STATE_REGISTERING_NETWORK;
log_info("Check for network registration"); tr_info("Check for network registration");
} else { } else {
static int retry_count; static int retry_count;
if (++retry_count <= 10) { if (++retry_count <= 10) {
log_warn("Waiting for SIM %d", retry_count); tr_warn("Waiting for SIM %d", retry_count);
event_timeout = 1000; event_timeout = 1000;
} else { } else {
report_failure("Entering SIM PIN"); report_failure("Entering SIM PIN");
@ -322,27 +322,27 @@ void CellularConnectionUtil::event()
_next_state = STATE_REGISTER_NETWORK; _next_state = STATE_REGISTER_NETWORK;
for (int type = 0; type < CellularNetwork::C_MAX; type++) { for (int type = 0; type < CellularNetwork::C_MAX; type++) {
if (get_network_registration((CellularNetwork::RegistrationType)type, status, is_registered)) { if (get_network_registration((CellularNetwork::RegistrationType)type, status, is_registered)) {
log_debug("get_network_registration: type=%d, status=%d", type, status); tr_debug("get_network_registration: type=%d, status=%d", type, status);
if (is_registered) { if (is_registered) {
log_info("Registered to cellular network (type %d, status %d)", type, status); tr_info("Registered to cellular network (type %d, status %d)", type, status);
_next_state = STATE_ATTACH_NETWORK; _next_state = STATE_ATTACH_NETWORK;
log_info("Check cellular network attach state"); tr_info("Check cellular network attach state");
break; break;
} else { } else {
if (status == CellularNetwork::RegistrationDenied) { if (status == CellularNetwork::RegistrationDenied) {
static int backoff_timeout = 1; static int backoff_timeout = 1;
log_warn("Network registration denied (type %d)! Retry after %d seconds.", type, backoff_timeout); tr_warn("Network registration denied (type %d)! Retry after %d seconds.", type, backoff_timeout);
event_timeout = backoff_timeout * 1000; event_timeout = backoff_timeout * 1000;
backoff_timeout *= 2; backoff_timeout *= 2;
break; break;
} else if (status != CellularNetwork::NotRegistered) { } else if (status != CellularNetwork::NotRegistered) {
static int retry_count; static int retry_count;
if (++retry_count <= 180) { if (++retry_count <= 180) {
log_info("Waiting for registration %d/180 (type %d, status %d)", retry_count, type, status); tr_info("Waiting for registration %d/180 (type %d, status %d)", retry_count, type, status);
event_timeout = 1*1000; event_timeout = 1*1000;
_next_state = STATE_REGISTERING_NETWORK; _next_state = STATE_REGISTERING_NETWORK;
} else { } else {
log_info("Start cellular registration"); tr_info("Start cellular registration");
_next_state = STATE_REGISTER_NETWORK; _next_state = STATE_REGISTER_NETWORK;
retry_count = 0; retry_count = 0;
break; break;
@ -356,7 +356,7 @@ void CellularConnectionUtil::event()
break; break;
case STATE_REGISTER_NETWORK: case STATE_REGISTER_NETWORK:
cellularDevice.set_timeout(TIMEOUT_REGISTRATION); cellularDevice.set_timeout(TIMEOUT_REGISTRATION);
log_info("Register to cellular network (timeout %d ms)", TIMEOUT_REGISTRATION); tr_info("Register to cellular network (timeout %d ms)", TIMEOUT_REGISTRATION);
if (set_network_registration()) { if (set_network_registration()) {
_next_state = STATE_REGISTERING_NETWORK; _next_state = STATE_REGISTERING_NETWORK;
} else { } else {
@ -384,17 +384,17 @@ void CellularConnectionUtil::event()
break; break;
case STATE_ATTACH_NETWORK: case STATE_ATTACH_NETWORK:
cellularDevice.set_timeout(TIMEOUT_NETWORK); cellularDevice.set_timeout(TIMEOUT_NETWORK);
log_info("Attach to cellular network (timeout %d ms)", TIMEOUT_NETWORK); tr_info("Attach to cellular network (timeout %d ms)", TIMEOUT_NETWORK);
if (set_attach_network()) { if (set_attach_network()) {
_next_state = STATE_ATTACHING_NETWORK; _next_state = STATE_ATTACHING_NETWORK;
log_info("Cellular network attaching"); tr_info("Cellular network attaching");
} else { } else {
event_timeout = 0; event_timeout = 0;
} }
break; break;
case STATE_CONNECT_NETWORK: case STATE_CONNECT_NETWORK:
cellularDevice.set_timeout(TIMEOUT_NETWORK); cellularDevice.set_timeout(TIMEOUT_NETWORK);
log_info("Connect to cellular network (timeout %d ms)", TIMEOUT_NETWORK); tr_info("Connect to cellular network (timeout %d ms)", TIMEOUT_NETWORK);
err = _network->connect(); err = _network->connect();
if (!err) { if (!err) {
_next_state = STATE_CONNECTED; _next_state = STATE_CONNECTED;
@ -405,7 +405,7 @@ void CellularConnectionUtil::event()
break; break;
case STATE_CONNECTED: case STATE_CONNECTED:
cellularDevice.set_timeout(TIMEOUT_NETWORK); cellularDevice.set_timeout(TIMEOUT_NETWORK);
log_debug("Cellular ready! (timeout %d ms)", TIMEOUT_NETWORK); tr_debug("Cellular ready! (timeout %d ms)", TIMEOUT_NETWORK);
if (_status_callback) { if (_status_callback) {
if (!_status_callback(_state, _next_state)) { if (!_status_callback(_state, _next_state)) {
return; return;
@ -419,7 +419,7 @@ void CellularConnectionUtil::event()
if (_next_state != _state || event_timeout >= 0) { if (_next_state != _state || event_timeout >= 0) {
if (_next_state != _state) { if (_next_state != _state) {
log_info("Cellular state from %d to %d", _state, _next_state); tr_info("Cellular state from %d to %d", _state, _next_state);
if (_status_callback) { if (_status_callback) {
if (!_status_callback(_state, _next_state)) { if (!_status_callback(_state, _next_state)) {
return; return;
@ -429,13 +429,13 @@ void CellularConnectionUtil::event()
if (event_timeout == 0) { if (event_timeout == 0) {
static int retry_count = 0; static int retry_count = 0;
if (++retry_count <= 3) { if (++retry_count <= 3) {
log_info("Cellular event retry %d", retry_count); tr_info("Cellular event retry %d", retry_count);
} else { } else {
report_failure("Cellular connection failed!"); report_failure("Cellular connection failed!");
return; return;
} }
} else { } else {
log_info("Cellular event in %d milliseconds", event_timeout); tr_info("Cellular event in %d milliseconds", event_timeout);
} }
} }
_state = _next_state; _state = _next_state;
@ -451,8 +451,8 @@ void CellularConnectionUtil::event()
nsapi_error_t CellularConnectionUtil::start_dispatch() nsapi_error_t CellularConnectionUtil::start_dispatch()
{ {
log_info("CellularConnectionUtil::start"); tr_info("CellularConnectionUtil::start");
log_info("Create cellular thread"); tr_info("Create cellular thread");
MBED_ASSERT(!_queue_thread); MBED_ASSERT(!_queue_thread);
@ -466,13 +466,13 @@ nsapi_error_t CellularConnectionUtil::start_dispatch()
return NSAPI_ERROR_NO_MEMORY; return NSAPI_ERROR_NO_MEMORY;
} }
log_info("CellularConnectionUtil::started"); tr_info("CellularConnectionUtil::started");
return NSAPI_ERROR_OK; return NSAPI_ERROR_OK;
} }
void CellularConnectionUtil::stop() void CellularConnectionUtil::stop()
{ {
log_info("CellularConnectionUtil::stop"); tr_info("CellularConnectionUtil::stop");
_cellularDevice->close_power(); _cellularDevice->close_power();
_cellularDevice->close_network(); _cellularDevice->close_network();
if (_queue_thread) { if (_queue_thread) {

10
features/cellular/easy_cellular/EasyCellularConnection.cpp
View File

@ -38,7 +38,7 @@ static UARTSerial cellularSerial(MDMTXD, MDMRXD, MBED_CONF_PLATFORM_DEFAULT_SERI
bool EasyCellularConnection::cellular_status(int state, int next_state) bool EasyCellularConnection::cellular_status(int state, int next_state)
{ {
log_info("cellular_status %d=>%d", state, next_state); tr_info("cellular_status %d=>%d", state, next_state);
if (_target_state == state) { if (_target_state == state) {
if (state == CellularConnectionUtil::STATE_CONNECTED) { if (state == CellularConnectionUtil::STATE_CONNECTED) {
_is_connected = true; _is_connected = true;
@ -56,7 +56,7 @@ bool EasyCellularConnection::cellular_status(int state, int next_state)
EasyCellularConnection::EasyCellularConnection() : _is_connected(false), _target_state(CellularConnectionUtil::STATE_POWER_ON) EasyCellularConnection::EasyCellularConnection() : _is_connected(false), _target_state(CellularConnectionUtil::STATE_POWER_ON)
{ {
log_info("EasyCellularConnection()"); tr_info("EasyCellularConnection()");
} }
EasyCellularConnection::~EasyCellularConnection() EasyCellularConnection::~EasyCellularConnection()
@ -66,8 +66,6 @@ EasyCellularConnection::~EasyCellularConnection()
nsapi_error_t EasyCellularConnection::init() nsapi_error_t EasyCellularConnection::init()
{ {
log_init(STDIO_UART_TX, STDIO_UART_RX, MBED_CONF_PLATFORM_STDIO_BAUD_RATE);
#if defined (MDMRTS) && defined (MDMCTS) #if defined (MDMRTS) && defined (MDMCTS)
cellularSerial.set_flow_control(SerialBase::RTSCTS, MDMRTS, MDMCTS); cellularSerial.set_flow_control(SerialBase::RTSCTS, MDMRTS, MDMCTS);
#endif #endif
@ -89,7 +87,7 @@ void EasyCellularConnection::set_credentials(const char *apn, const char *uname,
if (network) { if (network) {
network->set_credentials(apn, uname, pwd); network->set_credentials(apn, uname, pwd);
} else { } else {
log_error("NO Network..."); tr_error("NO Network...");
} }
} }
@ -112,7 +110,7 @@ nsapi_error_t EasyCellularConnection::connect()
if (err == NSAPI_ERROR_OK) { if (err == NSAPI_ERROR_OK) {
int ret_wait = cellularSemaphore.wait(10*60*1000); // cellular network searching may take several minutes int ret_wait = cellularSemaphore.wait(10*60*1000); // cellular network searching may take several minutes
if (ret_wait != 1) { if (ret_wait != 1) {
log_info("No cellular connection"); tr_info("No cellular connection");
err = NSAPI_ERROR_NO_CONNECTION; err = NSAPI_ERROR_NO_CONNECTION;
} }
} }

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

@ -228,7 +228,7 @@ void ATHandler::restore_at_timeout()
void ATHandler::process_oob() void ATHandler::process_oob()
{ {
lock(); lock();
log_debug("process_oob %d", (_fileHandle->readable() || (_recv_pos < _recv_len))); tr_debug("process_oob %d", (_fileHandle->readable() || (_recv_pos < _recv_len)));
if (_fileHandle->readable() || (_recv_pos < _recv_len)) { if (_fileHandle->readable() || (_recv_pos < _recv_len)) {
_current_scope = NotSet; _current_scope = NotSet;
Timer timer; Timer timer;
@ -254,7 +254,7 @@ void ATHandler::process_oob()
} }
} while (timer.read_ms() < 20); // URC's are very short so 20ms should be enough } while (timer.read_ms() < 20); // URC's are very short so 20ms should be enough
} }
log_debug("process_oob exit"); tr_debug("process_oob exit");
flush(); // consume anything that could not be handled flush(); // consume anything that could not be handled
@ -272,13 +272,13 @@ void ATHandler::set_filehandle_sigio()
void ATHandler::reset_buffer() void ATHandler::reset_buffer()
{ {
log_debug("%s", __func__); tr_debug("%s", __func__);
_recv_pos = 0; _recv_len = 0; _recv_pos = 0; _recv_len = 0;
} }
void ATHandler::rewind_buffer() void ATHandler::rewind_buffer()
{ {
log_debug("%s", __func__); tr_debug("%s", __func__);
if (_recv_pos > 0 && _recv_len >= _recv_pos) { if (_recv_pos > 0 && _recv_len >= _recv_pos) {
_recv_len -= _recv_pos; _recv_len -= _recv_pos;
// move what is not read to beginning of buffer // move what is not read to beginning of buffer
@ -290,7 +290,7 @@ void ATHandler::rewind_buffer()
// we are always expecting to receive something so there is wait timeout // we are always expecting to receive something so there is wait timeout
void ATHandler::fill_buffer() void ATHandler::fill_buffer()
{ {
log_debug("%s", __func__); tr_debug("%s", __func__);
// Reset buffer when full // Reset buffer when full
if (sizeof(_recv_buff) == _recv_len) { if (sizeof(_recv_buff) == _recv_len) {
reset_buffer(); reset_buffer();
@ -309,7 +309,7 @@ void ATHandler::fill_buffer()
at_debug("\n----------readable----------\n"); at_debug("\n----------readable----------\n");
return; return;
} else if (len != -EAGAIN && len != 0) { } else if (len != -EAGAIN && len != 0) {
log_warn("%s error: %d while reading", __func__, len); tr_warn("%s error: %d while reading", __func__, len);
break; break;
} }
#ifdef MBED_CONF_RTOS_PRESENT #ifdef MBED_CONF_RTOS_PRESENT
@ -318,29 +318,29 @@ void ATHandler::fill_buffer()
} while ((uint32_t)timer.read_ms() < _at_timeout); } while ((uint32_t)timer.read_ms() < _at_timeout);
set_error(NSAPI_ERROR_DEVICE_ERROR); set_error(NSAPI_ERROR_DEVICE_ERROR);
log_error("AT TIMEOUT, scope: %d timeout: %d", _current_scope, _at_timeout); tr_error("AT TIMEOUT, scope: %d timeout: %lu", _current_scope, _at_timeout);
} }
int ATHandler::get_char() int ATHandler::get_char()
{ {
if (_recv_pos == _recv_len) { if (_recv_pos == _recv_len) {
log_debug("%s", __func__); tr_debug("%s", __func__);
reset_buffer(); // try to read as much as possible reset_buffer(); // try to read as much as possible
fill_buffer(); fill_buffer();
if (get_last_error()) { if (get_last_error()) {
log_debug("%s: -1", __func__); tr_debug("%s: -1", __func__);
return -1; // timeout to read return -1; // timeout to read
} }
} }
log_debug("%s: %c", __func__, _recv_buff[_recv_pos]); tr_debug("%s: %c", __func__, _recv_buff[_recv_pos]);
return _recv_buff[_recv_pos++]; return _recv_buff[_recv_pos++];
} }
void ATHandler::skip_param(uint32_t count) void ATHandler::skip_param(uint32_t count)
{ {
log_debug("%s", __func__); tr_debug("%s", __func__);
if (_last_err || !_stop_tag || _stop_tag->found) { if (_last_err || !_stop_tag || _stop_tag->found) {
return; return;
} }
@ -370,7 +370,7 @@ void ATHandler::skip_param(uint32_t count)
void ATHandler::skip_param(ssize_t len, uint32_t count) void ATHandler::skip_param(ssize_t len, uint32_t count)
{ {
log_debug("%s", __func__); tr_debug("%s", __func__);
if (_last_err || !_stop_tag || _stop_tag->found) { if (_last_err || !_stop_tag || _stop_tag->found) {
return; return;
} }
@ -391,7 +391,7 @@ void ATHandler::skip_param(ssize_t len, uint32_t count)
ssize_t ATHandler::read_bytes(uint8_t *buf, size_t len) ssize_t ATHandler::read_bytes(uint8_t *buf, size_t len)
{ {
log_debug("%s", __func__); tr_debug("%s", __func__);
if (_last_err) { if (_last_err) {
return -1; return -1;
} }
@ -410,7 +410,7 @@ ssize_t ATHandler::read_bytes(uint8_t *buf, size_t len)
ssize_t ATHandler::read_string(char *buf, size_t size, bool read_even_stop_tag) ssize_t ATHandler::read_string(char *buf, size_t size, bool read_even_stop_tag)
{ {
log_debug("%s", __func__); tr_debug("%s", __func__);
at_debug("\n----------buff:----------\n"); at_debug("\n----------buff:----------\n");
for (size_t i = _recv_pos; i < _recv_len; i++) { for (size_t i = _recv_pos; i < _recv_len; i++) {
at_debug("%c", _recv_buff[i]); at_debug("%c", _recv_buff[i]);
@ -463,7 +463,7 @@ ssize_t ATHandler::read_string(char *buf, size_t size, bool read_even_stop_tag)
int32_t ATHandler::read_int() int32_t ATHandler::read_int()
{ {
log_debug("%s", __func__); tr_debug("%s", __func__);
if (_last_err || !_stop_tag || _stop_tag->found) { if (_last_err || !_stop_tag || _stop_tag->found) {
return -1; return -1;
@ -507,7 +507,7 @@ void ATHandler::set_stop_tag(const char *stop_tag_seq)
void ATHandler::set_scope(ScopeType scope_type) void ATHandler::set_scope(ScopeType scope_type)
{ {
log_debug("%s: %d", __func__, scope_type); tr_debug("%s: %d", __func__, scope_type);
if (_current_scope != scope_type) { if (_current_scope != scope_type) {
_current_scope = scope_type; _current_scope = scope_type;
switch (_current_scope) { switch (_current_scope) {
@ -536,7 +536,7 @@ void ATHandler::set_scope(ScopeType scope_type)
// should match from recv_pos? // should match from recv_pos?
bool ATHandler::match(const char* str, size_t size) bool ATHandler::match(const char* str, size_t size)
{ {
log_debug("%s: %s", __func__, str); tr_debug("%s: %s", __func__, str);
rewind_buffer(); rewind_buffer();
if ((_recv_len - _recv_pos) < size) { if ((_recv_len - _recv_pos) < size) {
@ -553,14 +553,14 @@ bool ATHandler::match(const char* str, size_t size)
bool ATHandler::match_urc() bool ATHandler::match_urc()
{ {
log_debug("%s", __func__); tr_debug("%s", __func__);
rewind_buffer(); rewind_buffer();
size_t prefix_len = 0; size_t prefix_len = 0;
for (struct oob_t *oob = _oobs; oob; oob = oob->next) { for (struct oob_t *oob = _oobs; oob; oob = oob->next) {
prefix_len = strlen(oob->prefix); prefix_len = strlen(oob->prefix);
if (_recv_len >= prefix_len) { if (_recv_len >= prefix_len) {
if (match(oob->prefix, prefix_len)) { if (match(oob->prefix, prefix_len)) {
log_debug("URC!"); tr_debug("URC!");
set_scope(InfoType); set_scope(InfoType);
if (oob->cb) { if (oob->cb) {
oob->cb(); oob->cb();
@ -575,7 +575,7 @@ bool ATHandler::match_urc()
bool ATHandler::match_error() bool ATHandler::match_error()
{ {
log_debug("%s", __func__); tr_debug("%s", __func__);
if (match(CME_ERROR, CME_ERROR_LENGTH)) { if (match(CME_ERROR, CME_ERROR_LENGTH)) {
at_error(true, DeviceErrorTypeErrorCME); at_error(true, DeviceErrorTypeErrorCME);
@ -616,7 +616,7 @@ void ATHandler::set_error(nsapi_error_t err)
} }
if (_last_err != err) { if (_last_err != err) {
log_warn("AT error code changed from %d to %d!", _last_err, err); tr_warn("AT error code changed from %d to %d!", _last_err, err);
} }
} }
@ -638,7 +638,7 @@ void ATHandler::set_3gpp_error(int err, DeviceErrorType error_type)
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) { if (map_3gpp_errors[i][0] == err) {
_last_3gpp_error = map_3gpp_errors[i][1]; _last_3gpp_error = map_3gpp_errors[i][1];
log_debug("AT3GPP error code %d", get_3gpp_error()); tr_debug("AT3GPP error code %d", get_3gpp_error());
break; break;
} }
} }
@ -657,9 +657,9 @@ void ATHandler::at_error(bool error_code_expected, DeviceErrorType error_type)
set_3gpp_error(err, error_type); set_3gpp_error(err, error_type);
_last_at_err.errCode = err; _last_at_err.errCode = err;
_last_at_err.errType = error_type; _last_at_err.errType = error_type;
log_debug("ATHandler ERROR: %d", err); tr_debug("ATHandler ERROR: %d", err);
} else { } else {
log_debug("ATHandler ERROR reading failed"); tr_debug("ATHandler ERROR reading failed");
} }
} }
@ -668,7 +668,7 @@ void ATHandler::at_error(bool error_code_expected, DeviceErrorType error_type)
void ATHandler::resp(const char *prefix, bool check_urc) void ATHandler::resp(const char *prefix, bool check_urc)
{ {
log_debug("%s: %s", __func__, prefix); tr_debug("%s: %s", __func__, prefix);
at_debug("\n----------buff:----------\n"); at_debug("\n----------buff:----------\n");
for (size_t i = _recv_pos; i < _recv_len; i++) { for (size_t i = _recv_pos; i < _recv_len; i++) {
@ -727,7 +727,7 @@ void ATHandler::resp(const char *prefix, bool check_urc)
void ATHandler::resp_start(const char *prefix, bool stop) void ATHandler::resp_start(const char *prefix, bool stop)
{ {
log_debug("%s: %s", __func__, prefix); tr_debug("%s: %s", __func__, prefix);
if (_last_err) { if (_last_err) {
return; return;
@ -757,7 +757,7 @@ void ATHandler::resp_start(const char *prefix, bool stop)
// check urc because of error as urc // check urc because of error as urc
bool ATHandler::info_resp() bool ATHandler::info_resp()
{ {
log_debug("%s", __func__); tr_debug("%s", __func__);
if (_last_err || _resp_stop.found) { if (_last_err || _resp_stop.found) {
return false; return false;
} }
@ -788,7 +788,7 @@ bool ATHandler::info_resp()
bool ATHandler::info_elem(char start_tag) bool ATHandler::info_elem(char start_tag)
{ {
log_debug("%s: %c", __func__, start_tag); tr_debug("%s: %c", __func__, start_tag);
if (_last_err) { if (_last_err) {
return false; return false;
} }
@ -814,7 +814,7 @@ bool ATHandler::info_elem(char start_tag)
bool ATHandler::consume_char(char ch) bool ATHandler::consume_char(char ch)
{ {
log_debug("%s: %c", __func__, ch); tr_debug("%s: %c", __func__, ch);
int read_char = get_char(); int read_char = get_char();
// If we read something else than ch, recover it // If we read something else than ch, recover it
if (read_char != ch && read_char != -1) { if (read_char != ch && read_char != -1) {
@ -826,7 +826,7 @@ bool ATHandler::consume_char(char ch)
bool ATHandler::consume_to_tag(const char *tag, bool consume_tag) bool ATHandler::consume_to_tag(const char *tag, bool consume_tag)
{ {
log_debug("%s: %s", __func__, tag); tr_debug("%s: %s", __func__, tag);
size_t match_pos = 0; size_t match_pos = 0;
while (true) { while (true) {
@ -845,13 +845,13 @@ bool ATHandler::consume_to_tag(const char *tag, bool consume_tag)
match_pos = 0; match_pos = 0;
} }
} }
log_error("consume_to_tag not found"); tr_error("consume_to_tag not found");
return false; return false;
} }
bool ATHandler::consume_to_stop_tag() bool ATHandler::consume_to_stop_tag()
{ {
log_debug("%s", __func__); tr_debug("%s", __func__);
if (!_stop_tag || (_stop_tag && _stop_tag->found) || _error_found) { if (!_stop_tag || (_stop_tag && _stop_tag->found) || _error_found) {
return true; return true;
@ -861,7 +861,7 @@ bool ATHandler::consume_to_stop_tag()
return true; return true;
} }
log_error("consume_to_stop_tag not found"); tr_error("consume_to_stop_tag not found");
set_error(NSAPI_ERROR_DEVICE_ERROR); set_error(NSAPI_ERROR_DEVICE_ERROR);
return false; return false;
} }
@ -872,7 +872,7 @@ void ATHandler::resp_stop()
{ {
// Do not return on error so that we can consume whatever there is in the buffer // Do not return on error so that we can consume whatever there is in the buffer
log_debug("%s", __func__); tr_debug("%s", __func__);
if (_current_scope == ElemType) { if (_current_scope == ElemType) {
information_response_element_stop(); information_response_element_stop();
@ -896,7 +896,7 @@ void ATHandler::resp_stop()
void ATHandler::information_response_stop() void ATHandler::information_response_stop()
{ {
log_debug("%s", __func__); tr_debug("%s", __func__);
if (consume_to_stop_tag()) { if (consume_to_stop_tag()) {
set_scope(RespType); set_scope(RespType);
} }
@ -904,7 +904,7 @@ void ATHandler::information_response_stop()
void ATHandler::information_response_element_stop() void ATHandler::information_response_element_stop()
{ {
log_debug("%s", __func__); tr_debug("%s", __func__);
if (consume_to_stop_tag()) { if (consume_to_stop_tag()) {
set_scope(InfoType); set_scope(InfoType);
} }
@ -936,7 +936,7 @@ const char* ATHandler::mem_str(const char* dest, size_t dest_len, const char* sr
void ATHandler::cmd_start(const char* cmd) void ATHandler::cmd_start(const char* cmd)
{ {
log_debug("AT> %s", cmd); tr_debug("AT> %s", cmd);
if (_last_err != NSAPI_ERROR_OK) { if (_last_err != NSAPI_ERROR_OK) {
return; return;

2
features/cellular/framework/AT/AT_CellularMultiplexer.cpp
View File

@ -30,7 +30,7 @@ AT_CellularMultiplexer::~AT_CellularMultiplexer()
nsapi_error_t AT_CellularMultiplexer::multiplexer_mode_start() nsapi_error_t AT_CellularMultiplexer::multiplexer_mode_start()
{ {
log_info("multiplexer_mode_start()"); tr_info("multiplexer_mode_start()");
_at.lock(); _at.lock();

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

@ -48,7 +48,7 @@ AT_CellularNetwork::AT_CellularNetwork(ATHandler &atHandler) : AT_CellularBase(a
#ifdef MBED_CONF_APP_CELLULAR_APN #ifdef MBED_CONF_APP_CELLULAR_APN
strncpy(_apn, MBED_CONF_APP_CELLULAR_APN, MAX_ACCESSPOINT_NAME_LENGTH); strncpy(_apn, MBED_CONF_APP_CELLULAR_APN, MAX_ACCESSPOINT_NAME_LENGTH);
log_debug("Using APN [%s] from json", _apn); tr_debug("Using APN [%s] from json", _apn);
#endif #endif
} }
@ -108,7 +108,7 @@ nsapi_error_t AT_CellularNetwork::connect()
nsapi_error_t err = set_context_to_be_activated(); nsapi_error_t err = set_context_to_be_activated();
if (err != NSAPI_ERROR_OK) { if (err != NSAPI_ERROR_OK) {
_at.unlock(); _at.unlock();
log_error("Failed to activate network context!"); tr_error("Failed to activate network context!");
_connect_status = NSAPI_STATUS_DISCONNECTED; _connect_status = NSAPI_STATUS_DISCONNECTED;
if (_connection_status_cb) { if (_connection_status_cb) {
@ -121,7 +121,7 @@ nsapi_error_t AT_CellularNetwork::connect()
err = open_data_channel(); err = open_data_channel();
if (err != NSAPI_ERROR_OK) { if (err != NSAPI_ERROR_OK) {
_at.unlock(); _at.unlock();
log_error("Failed to open data channel!"); tr_error("Failed to open data channel!");
_connect_status = NSAPI_STATUS_DISCONNECTED; _connect_status = NSAPI_STATUS_DISCONNECTED;
if (_connection_status_cb) { if (_connection_status_cb) {
@ -148,14 +148,14 @@ nsapi_error_t AT_CellularNetwork::open_data_channel()
//old way: _at.send("ATD*99***%d#", _cid) && _at.recv("CONNECT"); //old way: _at.send("ATD*99***%d#", _cid) && _at.recv("CONNECT");
nsapi_error_t err = NSAPI_ERROR_NO_CONNECTION; nsapi_error_t err = NSAPI_ERROR_NO_CONNECTION;
#if NSAPI_PPP_AVAILABLE #if NSAPI_PPP_AVAILABLE
log_info("Open data channel in PPP mode"); tr_info("Open data channel in PPP mode");
_at.cmd_start("AT+CGDATA=\"PPP\","); _at.cmd_start("AT+CGDATA=\"PPP\",");
_at.write_int(_cid); _at.write_int(_cid);
_at.cmd_stop(); _at.cmd_stop();
_at.resp_start("CONNECT", true); _at.resp_start("CONNECT", true);
if (_at.get_last_error()) { if (_at.get_last_error()) {
log_warn("Failed to CONNECT"); tr_warn("Failed to CONNECT");
} }
/* Initialize PPP /* Initialize PPP
* mbed_ppp_init() is a blocking call, it will block until * mbed_ppp_init() is a blocking call, it will block until
@ -182,7 +182,7 @@ nsapi_error_t AT_CellularNetwork::open_data_channel()
_at.resp_stop(); _at.resp_stop();
if (!is_context_active) { if (!is_context_active) {
log_info("Activate PDP context"); tr_info("Activate PDP context");
_at.cmd_start("AT+CGACT=1,"); _at.cmd_start("AT+CGACT=1,");
_at.write_int(_cid); _at.write_int(_cid);
_at.cmd_stop(); _at.cmd_stop();
@ -399,7 +399,7 @@ bool AT_CellularNetwork::get_context(nsapi_ip_stack_t requested_stack)
strncpy(_apn, apn, MAX_ACCESSPOINT_NAME_LENGTH); strncpy(_apn, apn, MAX_ACCESSPOINT_NAME_LENGTH);
} }
log_debug("Context id %d", _cid); tr_debug("Context id %d", _cid);
return true; return true;
} }
@ -446,18 +446,18 @@ nsapi_error_t AT_CellularNetwork::set_registration(const char *plmn)
nsapi_error_t ret = set_registration_urc(false); nsapi_error_t ret = set_registration_urc(false);
if (ret) { if (ret) {
log_error("Setting registration URC failed!"); tr_error("Setting registration URC failed!");
_at.clear_error(); // allow temporary failures here _at.clear_error(); // allow temporary failures here
} }
if (!plmn) { if (!plmn) {
log_debug("Automatic network registration"); tr_debug("Automatic network registration");
_at.cmd_start("AT+COPS=0"); _at.cmd_start("AT+COPS=0");
_at.cmd_stop(); _at.cmd_stop();
_at.resp_start(); _at.resp_start();
_at.resp_stop(); _at.resp_stop();
} else { } else {
log_debug("Manual network registration to %s", plmn); tr_debug("Manual network registration to %s", plmn);
_at.cmd_start("AT+COPS=4,2,"); _at.cmd_start("AT+COPS=4,2,");
_at.write_string(plmn); _at.write_string(plmn);
_at.cmd_stop(); _at.cmd_stop();
@ -525,12 +525,12 @@ nsapi_error_t AT_CellularNetwork::get_registration_status(RegistrationType type,
if (lac_read) { if (lac_read) {
_lac = hex_str_to_int(lac_string, LAC_LENGTH); _lac = hex_str_to_int(lac_string, LAC_LENGTH);
log_debug("lac %s %d", lac_string, _lac ); tr_debug("lac %s %d", lac_string, _lac );
} }
if (cell_id_read) { if (cell_id_read) {
_cell_id = hex_str_to_int(cell_id_string, CELL_ID_LENGTH); _cell_id = hex_str_to_int(cell_id_string, CELL_ID_LENGTH);
log_debug("cell_id %s %d", cell_id_string, _cell_id ); tr_debug("cell_id %s %d", cell_id_string, _cell_id );
} }
return ret; return ret;
@ -563,7 +563,7 @@ nsapi_error_t AT_CellularNetwork::set_attach(int timeout)
int attached_state = _at.read_int(); int attached_state = _at.read_int();
_at.resp_stop(); _at.resp_stop();
if (attached_state != 1) { if (attached_state != 1) {
log_debug("Network attach"); tr_debug("Network attach");
_at.cmd_start("AT+CGATT=1"); _at.cmd_start("AT+CGATT=1");
_at.cmd_stop(); _at.cmd_stop();
_at.resp_start(); _at.resp_start();
@ -776,7 +776,7 @@ nsapi_error_t AT_CellularNetwork::get_rate_control(
int next_element = _at.read_int(); int next_element = _at.read_int();
if (next_element >= 0) { if (next_element >= 0) {
reports = (RateControlExceptionReports)next_element; reports = (RateControlExceptionReports)next_element;
log_debug("reports %d",reports); tr_debug("reports %d",reports);
next_element = _at.read_int(); next_element = _at.read_int();
} else { } else {
comma_found = false; comma_found = false;
@ -784,7 +784,7 @@ nsapi_error_t AT_CellularNetwork::get_rate_control(
if (comma_found && next_element >= 0) { if (comma_found && next_element >= 0) {
timeUnit = (RateControlUplinkTimeUnit)next_element; timeUnit = (RateControlUplinkTimeUnit)next_element;
log_debug("time %d",timeUnit); tr_debug("time %d",timeUnit);
next_element = _at.read_int(); next_element = _at.read_int();
} else { } else {
comma_found = false; comma_found = false;
@ -792,7 +792,7 @@ nsapi_error_t AT_CellularNetwork::get_rate_control(
if (comma_found && next_element >= 0) { if (comma_found && next_element >= 0) {
uplinkRate = next_element; uplinkRate = next_element;
log_debug("rate %d",uplinkRate); tr_debug("rate %d",uplinkRate);
} }
} }
_at.resp_stop(); _at.resp_stop();
@ -828,7 +828,7 @@ nsapi_error_t AT_CellularNetwork::get_pdpcontext_params(pdpContextList_t& params
while (_at.info_resp()) { // response can be zero or many +CGDCONT lines while (_at.info_resp()) { // response can be zero or many +CGDCONT lines
params = params_list.add_new(); params = params_list.add_new();
if (!params) { if (!params) {
log_warn("Could not allocate new pdpcontext_params_t"); tr_warn("Could not allocate new pdpcontext_params_t");
params_list.delete_all(); params_list.delete_all();
_at.resp_stop(); _at.resp_stop();
free(temp); free(temp);

2
features/cellular/framework/AT/AT_CellularPower.cpp
View File

@ -203,7 +203,7 @@ nsapi_error_t AT_CellularPower::opt_power_save_mode(int periodic_time, int activ
if (_at.get_last_error() != NSAPI_ERROR_OK) { if (_at.get_last_error() != NSAPI_ERROR_OK) {
log_warn("Power save mode not enabled!"); tr_warn("Power save mode not enabled!");
} else { } else {
// network may not agree with power save options but // network may not agree with power save options but
// that should be fine as timeout is not longer than requested // that should be fine as timeout is not longer than requested

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

@ -48,11 +48,11 @@ nsapi_error_t AT_CellularSIM::get_sim_state(SimState &state)
state = SimStatePukNeeded; state = SimStatePukNeeded;
} else { } else {
simstr[len] = '\0'; simstr[len] = '\0';
log_error("Unknown SIM state %s", simstr); tr_error("Unknown SIM state %s", simstr);
state = SimStateUnknown; state = SimStateUnknown;
} }
} else { } else {
log_warn("SIM not readable."); tr_warn("SIM not readable.");
state = SimStateUnknown; // SIM may not be ready yet or +CPIN may be unsupported command state = SimStateUnknown; // SIM may not be ready yet or +CPIN may be unsupported command
} }
_at.resp_stop(); _at.resp_stop();

14
features/cellular/framework/AT/AT_CellularSMS.cpp
View File

@ -187,26 +187,26 @@ AT_CellularSMS::~AT_CellularSMS()
void AT_CellularSMS::cmt_urc() void AT_CellularSMS::cmt_urc()
{ {
log_debug("CMT_URC called"); tr_debug("CMT_URC called");
//+CMT: <oa>,[<alpha>],<scts>[,<tooa>,<fo>,<pid>,<dcs>,<sca>,<tosca>,<length>]<CR><LF><data> //+CMT: <oa>,[<alpha>],<scts>[,<tooa>,<fo>,<pid>,<dcs>,<sca>,<tosca>,<length>]<CR><LF><data>
_at.consume_to_stop_tag(); _at.consume_to_stop_tag();
// call user defined callback function // call user defined callback function
if (_cb) { if (_cb) {
_cb(); _cb();
} else { } else {
log_warn("cmt_urc, no user defined callback for receiving sms!"); tr_warn("cmt_urc, no user defined callback for receiving sms!");
} }
} }
void AT_CellularSMS::cmti_urc() void AT_CellularSMS::cmti_urc()
{ {
//+CMTI: <mem>,<index>, //+CMTI: <mem>,<index>,
log_debug("CMTI_URC called"); tr_debug("CMTI_URC called");
// call user defined callback function // call user defined callback function
if (_cb) { if (_cb) {
_cb(); _cb();
} else { } else {
log_warn("cmti_urc, no user defined callback for receiving sms!"); tr_warn("cmti_urc, no user defined callback for receiving sms!");
} }
} }
@ -718,7 +718,7 @@ nsapi_size_or_error_t AT_CellularSMS::read_sms(sms_info_t* sms, char* buf, char*
} }
} }
else { else {
log_warn("NOT all concatenated parts were received..."); tr_warn("NOT all concatenated parts were received...");
index = SMS_ERROR_MULTIPART_ALL_PARTS_NOT_READ; index = SMS_ERROR_MULTIPART_ALL_PARTS_NOT_READ;
} }
@ -743,7 +743,7 @@ nsapi_size_or_error_t AT_CellularSMS::get_sms(char* buf, uint16_t len, char* pho
if (info) { if (info) {
if (info->msg_size+1 > len) { // +1 for '\0' if (info->msg_size+1 > len) { // +1 for '\0'
log_warn("Given buf too small, len is: %d but is must be: %d", len, info->msg_size); tr_warn("Given buf too small, len is: %d but is must be: %d", len, info->msg_size);
if (buf_size) { if (buf_size) {
*buf_size = info->msg_size; *buf_size = info->msg_size;
} }
@ -978,7 +978,7 @@ nsapi_size_or_error_t AT_CellularSMS::read_pdu_payload(const char* pdu, int sche
// 8bit scheme so just convert hexstring to charstring // 8bit scheme so just convert hexstring to charstring
return hex_str_to_char_str(pdu, strlen(pdu), msg); return hex_str_to_char_str(pdu, strlen(pdu), msg);
} else { } else {
log_error("Received unsupported data coding scheme: 0x%02x", scheme); tr_error("Received unsupported data coding scheme: 0x%02x", scheme);
return NSAPI_ERROR_UNSUPPORTED; return NSAPI_ERROR_UNSUPPORTED;
} }
} }

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

@ -1,67 +0,0 @@
/*
* Copyright (c) , 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 <stdarg.h>
#include <stddef.h>
#include "CellularLog.h"
#include "us_ticker_api.h"
#include "serial_api.h"
#include "rtos/Mutex.h"
extern serial_t stdio_uart;
extern int stdio_uart_inited;
namespace mbed {
uint32_t cellular_log_time = us_ticker_read() / 1000L;
/**
* Local mutex object for synchronization
*/
static rtos::Mutex mutex;
/**
* Lock provided for serial printing used by trace library
*/
static void serial_lock()
{
mutex.lock();
}
/**
* Releasing lock provided for serial printing used by trace library
*/
static void serial_unlock()
{
mutex.unlock();
}
void log_init(PinName tx, PinName rx, int baud)
{
#ifdef FEATURE_COMMON_PAL
mbed_trace_mutex_wait_function_set(serial_lock);
mbed_trace_mutex_release_function_set(serial_unlock);
mbed_trace_init();
#else
serial_init(&stdio_uart, tx, rx);
serial_baud(&stdio_uart, baud);
stdio_uart_inited = 1;
#endif
log_info("\r\n\r\n**************************************");
log_info("Hellular says Cellular Hello!");
log_info("Build time %s %s", __DATE__, __TIME__);
}
} // namespace mbed

69
features/cellular/framework/common/CellularLog.h
View File

@ -18,65 +18,24 @@
#ifndef CELLULAR_LOG_H_ #ifndef CELLULAR_LOG_H_
#define CELLULAR_LOG_H_ #define CELLULAR_LOG_H_
#include <inttypes.h> #if defined(HAVE_DEBUG) && !defined(FEA_TRACE_SUPPORT)
#ifdef FEATURE_COMMON_PAL #define FEA_TRACE_SUPPORT
#include <stdarg.h>
#endif // FEATURE_COMMON_PAL
#include "PinNames.h"
#include "us_ticker_api.h"
#include "mbed_debug.h"
namespace mbed {
/** this print is some deep information for debug purpose */
#define TRACE_LEVEL_DEBUG 0x10
/** Info print, for general purpose prints */
#define TRACE_LEVEL_INFO 0x08
/** warning prints, which shouldn't causes any huge problems */
#define TRACE_LEVEL_WARN 0x04
/** Error prints, which causes probably problems, e.g. out of mem. */
#define TRACE_LEVEL_ERROR 0x02
/** special level for cmdline. Behaviours like "plain mode" */
#define TRACE_LEVEL_CMD 0x01
#define TRACE_GROUP "cellular"
#ifndef MBED_TRACE_MAX_LEVEL
#define MBED_TRACE_MAX_LEVEL TRACE_LEVEL_ERROR
#endif #endif
#ifdef FEATURE_COMMON_PAL #if defined(FEATURE_COMMON_PAL)
#include "mbed-trace/mbed_trace.h" #include "mbed-trace/mbed_trace.h"
#define log_debug tr_debug #ifndef TRACE_GROUP
#define log_info tr_info #define TRACE_GROUP "cellular"
#define log_warn tr_warn #endif // TRACE_GROUP
#define log_error tr_error
#else
extern uint32_t cellular_log_time;
#if (MBED_TRACE_MAX_LEVEL >= TRACE_LEVEL_DEBUG)
#define log_debug(format, ...) do { debug("DEBUG" " [" TRACE_GROUP " %ums] " format "\r\n", (us_ticker_read()-cellular_log_time) / 1000L, ## __VA_ARGS__); } while (0)
#else
#define log_debug(...)
#endif
#if (MBED_TRACE_MAX_LEVEL >= TRACE_LEVEL_INFO)
#define log_info(format, ...) do { debug("INFO" " [" TRACE_GROUP " %ums] " format "\r\n", (us_ticker_read()-cellular_log_time) / 1000L, ## __VA_ARGS__); } while (0)
#else
#define log_info(...)
#endif
#if (MBED_TRACE_MAX_LEVEL >= TRACE_LEVEL_WARN)
#define log_warn(format, ...) do { debug("WARN" " [" TRACE_GROUP " %ums] " format "\r\n", (us_ticker_read()-cellular_log_time) / 1000L, ## __VA_ARGS__); } while (0)
#else
#define log_warn(...)
#endif
#if (MBED_TRACE_MAX_LEVEL >= TRACE_LEVEL_ERROR)
#define log_error(format, ...) do { debug("ERROR" " [" TRACE_GROUP " %ums] " format "\r\n", (us_ticker_read()-cellular_log_time) / 1000L, ## __VA_ARGS__); } while (0)
#else
#define log_error(...)
#endif
#endif
extern void log_init(PinName tx, PinName rx, int baud); #else
} // namespace mbed #define tr_debug(...) (void(0))
#define tr_info(...) (void(0))
#define tr_error(...) (void(0))
#define tr_warn(...) (void(0))
#endif // FEATURE_COMMON_PAL
#endif // CELLULAR_LOG_H_ #endif // CELLULAR_LOG_H_