From 67a991ff3d772d2f81cb9907e1a710a88436f7c7 Mon Sep 17 00:00:00 2001 From: "mykola.salomatin" Date: Thu, 15 Apr 2021 17:52:10 +0300 Subject: [MTX-3998] mPower R. Apr 2021: +CEMODE shall be set to CEMODE=2 - Quectel - GP-1111 Added CEMODE switching support for Quectel radios --- include/mts/MTS_IO_ICellularRadio.h | 10 ++- include/mts/MTS_IO_QuectelRadio.h | 12 +++ src/MTS_IO_ICellularRadio.cpp | 14 ++++ src/MTS_IO_QuectelRadio.cpp | 153 ++++++++++++++++++++++++++++++++++++ 4 files changed, 185 insertions(+), 4 deletions(-) diff --git a/include/mts/MTS_IO_ICellularRadio.h b/include/mts/MTS_IO_ICellularRadio.h index e8ae891..c35e903 100644 --- a/include/mts/MTS_IO_ICellularRadio.h +++ b/include/mts/MTS_IO_ICellularRadio.h @@ -70,10 +70,12 @@ namespace MTS { enum UE_MODES_OF_OPERATION : uint8_t { UNKNOWN_MODE = 0, // current mode of operation is not available - PS_MODE1, // only EPS (LTE) services are allowed, the usage is “voice centric” - PS_MODE2, // only EPS (LTE) services are allowed, the usage is “data centric” - CS_PS_MODE1, // both EPS and non-EPS services are allowed, the usage is “voice centric” - CS_PS_MODE2 // both EPS and non-EPS services are allowed, the usage is “data centric” + PS_MODE1, // only EPS (LTE) services are allowed, the usage is "voice centric" + PS_MODE2, // only EPS (LTE) services are allowed, the usage is "data centric" + CS_PS_MODE1, // both EPS and non-EPS services are allowed, the usage is "voice centric" + CS_PS_MODE2, // both EPS and non-EPS services are allowed, the usage is "data centric" + CS_MODE1, // only non-EPS services are allowed, the usage is "voice centric" + CS_MODE2 // only non-EPS services are allowed, the usage is "data centric" }; static CODE convertModelToType(const std::string& sModel, std::string& sType); diff --git a/include/mts/MTS_IO_QuectelRadio.h b/include/mts/MTS_IO_QuectelRadio.h index 9713f48..04c0ef9 100644 --- a/include/mts/MTS_IO_QuectelRadio.h +++ b/include/mts/MTS_IO_QuectelRadio.h @@ -51,7 +51,16 @@ namespace MTS { CODE fumoLocalCleanup() override; CODE fumoLocalApply(UpdateCb& stepCb) override; + CODE setUeModeOfOperation(UE_MODES_OF_OPERATION mode) override; + CODE getUeModeOfOperation(UE_MODES_OF_OPERATION& mode) override; + protected: + enum class UE_USAGE_SETTING : uint8_t { + UNKNOWN_MODE = 0, // Unknown mode + MODE_1, // Voice centric mode + MODE_2 // Data centric mode + }; + QuectelRadio(const std::string& sName, const std::string& sRadioPort); CODE getIsSimInserted(bool& bData) override; @@ -64,6 +73,9 @@ namespace MTS { virtual CODE removeFile(const std::string& sTargetFilename); virtual CODE checkFile(bool& bFilePresent, const std::string& sTargetFilename); + virtual CODE getUeUsageSetting(UE_USAGE_SETTING& us); + virtual CODE convertToUeUsageSetting(const std::string& sSetting, UE_USAGE_SETTING& us); + private: // private variable to save old firmware versions during FOTA std::string m_sQuectelFirmware; diff --git a/src/MTS_IO_ICellularRadio.cpp b/src/MTS_IO_ICellularRadio.cpp index 9f63408..1fbad0c 100644 --- a/src/MTS_IO_ICellularRadio.cpp +++ b/src/MTS_IO_ICellularRadio.cpp @@ -532,6 +532,14 @@ MTS::IO::ICellularRadio::CODE MTS::IO::ICellularRadio::convertUeModeToString(MTS string = "csps_2"; rc = CODE::SUCCESS; break; + case ICellularRadio::UE_MODES_OF_OPERATION::CS_MODE1: + string = "cs_1"; + rc = CODE::SUCCESS; + break; + case ICellularRadio::UE_MODES_OF_OPERATION::CS_MODE2: + string = "cs_2"; + rc = CODE::SUCCESS; + break; default: string = MTS::IO::ICellularRadio::VALUE_UNKNOWN; rc = CODE::FAILURE; @@ -555,6 +563,12 @@ MTS::IO::ICellularRadio::CODE MTS::IO::ICellularRadio::convertStringToUeMode(con } else if (sMode == "csps_2") { mode = ICellularRadio::UE_MODES_OF_OPERATION::CS_PS_MODE2; rc = CODE::SUCCESS; + } else if (sMode == "cs_1") { + mode = ICellularRadio::UE_MODES_OF_OPERATION::CS_MODE1; + rc = CODE::SUCCESS; + } else if (sMode == "cs_2") { + mode = ICellularRadio::UE_MODES_OF_OPERATION::CS_MODE2; + rc = CODE::SUCCESS; } else { mode = ICellularRadio::UNKNOWN_MODE; rc = CODE::FAILURE; diff --git a/src/MTS_IO_QuectelRadio.cpp b/src/MTS_IO_QuectelRadio.cpp index aeb06ab..4f20627 100644 --- a/src/MTS_IO_QuectelRadio.cpp +++ b/src/MTS_IO_QuectelRadio.cpp @@ -1221,3 +1221,156 @@ ICellularRadio::CODE QuectelRadio::abortFileUpload() { sleep(1); return sendBasicCommand(CMD_ABORT_UPLOAD, 2000, 0x00); } + +ICellularRadio::CODE QuectelRadio::setUeModeOfOperation(UE_MODES_OF_OPERATION mode) { + std::string sDomain, sPreference; + + switch (mode) { + case UE_MODES_OF_OPERATION::CS_MODE1: + sDomain = "0"; + sPreference = "00"; + break; + case UE_MODES_OF_OPERATION::CS_MODE2: + sDomain = "0"; + sPreference = "01"; + break; + case UE_MODES_OF_OPERATION::PS_MODE1: + sDomain = "1"; + sPreference = "00"; + break; + case UE_MODES_OF_OPERATION::PS_MODE2: + sDomain = "1"; + sPreference = "01"; + break; + case UE_MODES_OF_OPERATION::CS_PS_MODE1: + sDomain = "2"; + sPreference = "00"; + break; + case UE_MODES_OF_OPERATION::CS_PS_MODE2: + sDomain = "2"; + sPreference = "01"; + break; + default: + printTrace("Set UE Mode Of Operation: invalid argument"); + return INVALID_ARGS; + } + + CODE rc; + const int dTimeout = 1000; // ms + std::string sCommand = "AT+QNVFW=\"/nv/item_files/modem/mmode/ue_usage_setting\"," + sPreference; + + rc = sendBasicCommand(sCommand, dTimeout); + if (rc != SUCCESS) { + printError("Voice/data preference configuration failed with code [%d]", rc); + return rc; + } + + sCommand = "AT+QCFG=\"servicedomain\"," + sDomain + ",0"; + + rc = sendBasicCommand(sCommand, dTimeout); + if (rc != SUCCESS) { + printError("Service domain configuration failed with code [%d]", rc); + return rc; + } + + return SUCCESS; +} + +ICellularRadio::CODE QuectelRadio::getUeUsageSetting(UE_USAGE_SETTING& us) { + printTrace("%s| Get UE Usage Setting", getName().c_str()); + + std::string sCmd("AT+QNVFR=\"/nv/item_files/modem/mmode/ue_usage_setting\""); + std::string sResult = sendCommand(sCmd); + size_t end = sResult.find(ICellularRadio::RSP_OK); + + if (end == std::string::npos) { + printError("%s| Unable to get UE Usage Setting [%s]", getName().c_str(), sResult.c_str()); + return FAILURE; + } + + // +QNVFR: + const std::string sLabel = "+QNVFR: "; + size_t start = sResult.find(sLabel); + if (start == std::string::npos) { + printError("%s| Failed to parse UE Usage Setting from output [%s]", getName().c_str(), sResult.c_str()); + return FAILURE; + } + + start += sLabel.length(); + const std::string sPreference = MTS::Text::trim(sResult.substr(start, end - start)); + + if (convertToUeUsageSetting(sPreference, us) != SUCCESS) { + printError("%s| Unable to convert [%s] to UE Usage Setting", getName().c_str(), sPreference.c_str()); + return FAILURE; + } + + return SUCCESS; +} + +ICellularRadio::CODE QuectelRadio::convertToUeUsageSetting(const std::string& sSetting, UE_USAGE_SETTING& us) { + if (sSetting == "00") { + us = UE_USAGE_SETTING::MODE_1; + return SUCCESS; + } + + if (sSetting == "01") { + us = UE_USAGE_SETTING::MODE_2; + return SUCCESS; + } + + us = UE_USAGE_SETTING::UNKNOWN_MODE; + return FAILURE; +} + +ICellularRadio::CODE QuectelRadio::getUeModeOfOperation(UE_MODES_OF_OPERATION& mode) { + printTrace("%s| Get UE Mode Of Operation", getName().c_str()); + + SERVICEDOMAIN sd; + UE_USAGE_SETTING us; + + if (getServiceDomain(sd) != SUCCESS) { + return FAILURE; + } + + printTrace("%s| Retrieved servicedomain [%d]", getName().c_str(), sd); + + if (getUeUsageSetting(us) != SUCCESS) { + return FAILURE; + } + + printTrace("%s| Retrieved ue_usage_setting [%d]", getName().c_str(), us); + + if (sd == SERVICEDOMAIN::CS_ONLY && us == UE_USAGE_SETTING::MODE_1) { + mode = UE_MODES_OF_OPERATION::CS_MODE1; + return SUCCESS; + } + + if (sd == SERVICEDOMAIN::CS_ONLY && us == UE_USAGE_SETTING::MODE_2) { + mode = UE_MODES_OF_OPERATION::CS_MODE2; + return SUCCESS; + } + + if (sd == SERVICEDOMAIN::PS_ONLY && us == UE_USAGE_SETTING::MODE_1) { + mode = UE_MODES_OF_OPERATION::PS_MODE1; + return SUCCESS; + } + + if (sd == SERVICEDOMAIN::PS_ONLY && us == UE_USAGE_SETTING::MODE_2) { + mode = UE_MODES_OF_OPERATION::PS_MODE2; + return SUCCESS; + } + + if (sd == SERVICEDOMAIN::CSPS && us == UE_USAGE_SETTING::MODE_1) { + mode = UE_MODES_OF_OPERATION::CS_PS_MODE1; + return SUCCESS; + } + + if (sd == SERVICEDOMAIN::CSPS && us == UE_USAGE_SETTING::MODE_2) { + mode = UE_MODES_OF_OPERATION::CS_PS_MODE2; + return SUCCESS; + } + + printError("%s| Unknown combination of servicedomain [%d] and ue_usage_setting [%d]", getName().c_str(), sd, us); + mode = UE_MODES_OF_OPERATION::UNKNOWN_MODE; + return FAILURE; +} -- cgit v1.2.3 From 6cab1e29fc2031a76c87e49c3bcdd7c5db8f40dc Mon Sep 17 00:00:00 2001 From: "mykola.salomatin" Date: Thu, 15 Apr 2021 20:47:36 +0300 Subject: [MTX-3998] mPower R. Apr 2021: +CEMODE shall be set to CEMODE=2 - Quectel - GP-1111 Refactoring common functions, telit and quectel functions related to CEMODE switching --- include/mts/MTS_IO_CellularRadio.h | 4 +- include/mts/MTS_IO_ICellularRadio.h | 6 +-- include/mts/MTS_IO_LE910Radio.h | 4 +- src/MTS_IO_CellularRadio.cpp | 10 ++--- src/MTS_IO_ICellularRadio.cpp | 73 ++++++++++++++++++------------------- src/MTS_IO_LE910Radio.cpp | 62 ++++++++++++++++--------------- src/MTS_IO_QuectelRadio.cpp | 8 ++-- 7 files changed, 86 insertions(+), 81 deletions(-) diff --git a/include/mts/MTS_IO_CellularRadio.h b/include/mts/MTS_IO_CellularRadio.h index 6840398..b245c48 100644 --- a/include/mts/MTS_IO_CellularRadio.h +++ b/include/mts/MTS_IO_CellularRadio.h @@ -134,8 +134,8 @@ namespace MTS { virtual std::string waitResponse(IsNeedMoreData& isNeedMoreData, int32_t timeoutMillis = 100) override; - CODE setUeModeOfOperation(UE_MODES_OF_OPERATION newmode) override; - CODE getUeModeOfOperation(UE_MODES_OF_OPERATION& newmode) override; + CODE setUeModeOfOperation(UE_MODES_OF_OPERATION mode) override; + CODE getUeModeOfOperation(UE_MODES_OF_OPERATION& mode) override; protected: diff --git a/include/mts/MTS_IO_ICellularRadio.h b/include/mts/MTS_IO_ICellularRadio.h index c35e903..63cedbe 100644 --- a/include/mts/MTS_IO_ICellularRadio.h +++ b/include/mts/MTS_IO_ICellularRadio.h @@ -82,7 +82,7 @@ namespace MTS { static CODE convertModelToMtsShortCode(const std::string& sModel, std::string& sCode, ICellularRadio *radioObj = NULL); static CODE convertServiceDomainToString(SERVICEDOMAIN eSd, std::string& sSd); static CODE convertActiveBandToString(ACTIVEBAND eBand, std::string& sBand); - static CODE convertUeModeToString(UE_MODES_OF_OPERATION mode, std::string& string); + static CODE convertUeModeToString(UE_MODES_OF_OPERATION mode, std::string& sMode); static CODE convertStringToUeMode(const std::string& sMode, UE_MODES_OF_OPERATION& mode); static std::string sendCommand(MTS::AutoPtr& apIo, @@ -575,8 +575,8 @@ namespace MTS { int32_t timeoutMillis = 100) = 0; - virtual CODE setUeModeOfOperation(UE_MODES_OF_OPERATION newmode) = 0; - virtual CODE getUeModeOfOperation(UE_MODES_OF_OPERATION& newmode) = 0; + virtual CODE setUeModeOfOperation(UE_MODES_OF_OPERATION mode) = 0; + virtual CODE getUeModeOfOperation(UE_MODES_OF_OPERATION& mode) = 0; }; } } diff --git a/include/mts/MTS_IO_LE910Radio.h b/include/mts/MTS_IO_LE910Radio.h index e8a0dec..f64600d 100644 --- a/include/mts/MTS_IO_LE910Radio.h +++ b/include/mts/MTS_IO_LE910Radio.h @@ -45,8 +45,8 @@ namespace MTS { CODE setRxDiversity(const Json::Value& jArgs); CODE getModemLocation(std::string& sLocation); - CODE setUeModeOfOperation(UE_MODES_OF_OPERATION newmode) override; - CODE getUeModeOfOperation(UE_MODES_OF_OPERATION &newmode) override; + CODE setUeModeOfOperation(UE_MODES_OF_OPERATION mode) override; + CODE getUeModeOfOperation(UE_MODES_OF_OPERATION& mode) override; protected: diff --git a/src/MTS_IO_CellularRadio.cpp b/src/MTS_IO_CellularRadio.cpp index 49bdcb4..81e3332 100644 --- a/src/MTS_IO_CellularRadio.cpp +++ b/src/MTS_IO_CellularRadio.cpp @@ -1379,13 +1379,13 @@ ICellularRadio::CODE CellularRadio::readChunk(int fd, char* pChunk, size_t dChun return rc; } -ICellularRadio::CODE CellularRadio::setUeModeOfOperation(UE_MODES_OF_OPERATION newmode) { +ICellularRadio::CODE CellularRadio::setUeModeOfOperation(UE_MODES_OF_OPERATION mode) { printTrace("%s| Set UE Mode Of Operation: not applicable", m_sName.c_str()); - return CODE::NOT_APPLICABLE; + return NOT_APPLICABLE; } -ICellularRadio::CODE CellularRadio::getUeModeOfOperation(UE_MODES_OF_OPERATION &newmode) { +ICellularRadio::CODE CellularRadio::getUeModeOfOperation(UE_MODES_OF_OPERATION& mode) { printTrace("%s| Get UE Mode Of Operation: not applicable", m_sName.c_str()); - newmode = UE_MODES_OF_OPERATION::UNKNOWN_MODE; - return CODE::NOT_APPLICABLE; + mode = UE_MODES_OF_OPERATION::UNKNOWN_MODE; + return NOT_APPLICABLE; } diff --git a/src/MTS_IO_ICellularRadio.cpp b/src/MTS_IO_ICellularRadio.cpp index 1fbad0c..3394b4e 100644 --- a/src/MTS_IO_ICellularRadio.cpp +++ b/src/MTS_IO_ICellularRadio.cpp @@ -513,65 +513,64 @@ std::string MTS::IO::ICellularRadio::getCodeAsString(CODE eCode) { } } -MTS::IO::ICellularRadio::CODE MTS::IO::ICellularRadio::convertUeModeToString(MTS::IO::ICellularRadio::UE_MODES_OF_OPERATION mode, std::string &string) { +MTS::IO::ICellularRadio::CODE MTS::IO::ICellularRadio::convertUeModeToString(UE_MODES_OF_OPERATION mode, std::string& sMode) { CODE rc; switch (mode) { - case ICellularRadio::UE_MODES_OF_OPERATION::PS_MODE1: - string = "ps_1"; - rc = CODE::SUCCESS; + case UE_MODES_OF_OPERATION::PS_MODE1: + sMode = "ps_1"; + rc = SUCCESS; break; - case ICellularRadio::UE_MODES_OF_OPERATION::PS_MODE2: - string = "ps_2"; - rc = CODE::SUCCESS; + case UE_MODES_OF_OPERATION::PS_MODE2: + sMode = "ps_2"; + rc = SUCCESS; break; - case ICellularRadio::UE_MODES_OF_OPERATION::CS_PS_MODE1: - string = "csps_1"; - rc = CODE::SUCCESS; + case UE_MODES_OF_OPERATION::CS_PS_MODE1: + sMode = "csps_1"; + rc = SUCCESS; break; - case ICellularRadio::UE_MODES_OF_OPERATION::CS_PS_MODE2: - string = "csps_2"; - rc = CODE::SUCCESS; + case UE_MODES_OF_OPERATION::CS_PS_MODE2: + sMode = "csps_2"; + rc = SUCCESS; break; - case ICellularRadio::UE_MODES_OF_OPERATION::CS_MODE1: - string = "cs_1"; - rc = CODE::SUCCESS; + case UE_MODES_OF_OPERATION::CS_MODE1: + sMode = "cs_1"; + rc = SUCCESS; break; - case ICellularRadio::UE_MODES_OF_OPERATION::CS_MODE2: - string = "cs_2"; - rc = CODE::SUCCESS; + case UE_MODES_OF_OPERATION::CS_MODE2: + sMode = "cs_2"; + rc = SUCCESS; break; default: - string = MTS::IO::ICellularRadio::VALUE_UNKNOWN; - rc = CODE::FAILURE; + sMode = ICellularRadio::VALUE_UNKNOWN; + rc = FAILURE; break; } return rc; } -MTS::IO::ICellularRadio::CODE MTS::IO::ICellularRadio::convertStringToUeMode(const std::string &sMode, UE_MODES_OF_OPERATION& mode) { - using namespace MTS::IO; +MTS::IO::ICellularRadio::CODE MTS::IO::ICellularRadio::convertStringToUeMode(const std::string& sMode, UE_MODES_OF_OPERATION& mode) { CODE rc; if (sMode == "ps_1") { - mode = ICellularRadio::UE_MODES_OF_OPERATION::PS_MODE1; - rc = CODE::SUCCESS; + mode = UE_MODES_OF_OPERATION::PS_MODE1; + rc = SUCCESS; } else if (sMode == "ps_2") { - mode = ICellularRadio::UE_MODES_OF_OPERATION::PS_MODE2; - rc = CODE::SUCCESS; + mode = UE_MODES_OF_OPERATION::PS_MODE2; + rc = SUCCESS; } else if (sMode == "csps_1") { - mode = ICellularRadio::UE_MODES_OF_OPERATION::CS_PS_MODE1; - rc = CODE::SUCCESS; + mode = UE_MODES_OF_OPERATION::CS_PS_MODE1; + rc = SUCCESS; } else if (sMode == "csps_2") { - mode = ICellularRadio::UE_MODES_OF_OPERATION::CS_PS_MODE2; - rc = CODE::SUCCESS; + mode = UE_MODES_OF_OPERATION::CS_PS_MODE2; + rc = SUCCESS; } else if (sMode == "cs_1") { - mode = ICellularRadio::UE_MODES_OF_OPERATION::CS_MODE1; - rc = CODE::SUCCESS; + mode = UE_MODES_OF_OPERATION::CS_MODE1; + rc = SUCCESS; } else if (sMode == "cs_2") { - mode = ICellularRadio::UE_MODES_OF_OPERATION::CS_MODE2; - rc = CODE::SUCCESS; + mode = UE_MODES_OF_OPERATION::CS_MODE2; + rc = SUCCESS; } else { - mode = ICellularRadio::UNKNOWN_MODE; - rc = CODE::FAILURE; + mode = UE_MODES_OF_OPERATION::UNKNOWN_MODE; + rc = FAILURE; } return rc; } diff --git a/src/MTS_IO_LE910Radio.cpp b/src/MTS_IO_LE910Radio.cpp index 764ac5e..74cf5c1 100644 --- a/src/MTS_IO_LE910Radio.cpp +++ b/src/MTS_IO_LE910Radio.cpp @@ -78,51 +78,55 @@ ICellularRadio::CODE LE910Radio::getModemLocation(std::string& sLocation) { return SUCCESS; } -ICellularRadio::CODE LE910Radio::setUeModeOfOperation(ICellularRadio::UE_MODES_OF_OPERATION newmode) { - uint8_t iValue; +ICellularRadio::CODE LE910Radio::setUeModeOfOperation(UE_MODES_OF_OPERATION mode) { + printTrace("%s| Set UE Mode Of Operation", getName().c_str()); - switch (newmode) { + std::string sValue; + + switch (mode) { case UE_MODES_OF_OPERATION::PS_MODE1: - iValue = 3; + sValue = "3"; break; case UE_MODES_OF_OPERATION::PS_MODE2: - iValue = 0; + sValue = "0"; break; case UE_MODES_OF_OPERATION::CS_PS_MODE1: - iValue = 1; + sValue = "1"; break; case UE_MODES_OF_OPERATION::CS_PS_MODE2: - iValue = 2; + sValue = "2"; break; default: - printTrace("Set UE Mode Of Operation: invalid argument"); - return CODE::INVALID_ARGS; + printError("%s| Set UE Mode Of Operation: invalid argument", getName().c_str()); + return INVALID_ARGS; } const int dTimeout = 1000; // ms - const std::string sCommand = "AT+CEMODE=" + MTS::Text::format(iValue); + const std::string sCommand = "AT+CEMODE=" + sValue; return sendBasicCommand(sCommand, dTimeout); } -ICellularRadio::CODE LE910Radio::getUeModeOfOperation(ICellularRadio::UE_MODES_OF_OPERATION& newmode) { +ICellularRadio::CODE LE910Radio::getUeModeOfOperation(UE_MODES_OF_OPERATION& mode) { + printTrace("%s| Get UE Mode Of Operation", getName().c_str()); + const std::string sCommand = "AT+CEMODE?"; const int dTimeout = 1000; // ms std::string sResult = sendCommand(sCommand, ICellularRadio::DEFAULT_BAIL_STRINGS, dTimeout); - printTrace("Got response from the radio: %s", sResult.c_str()); + printTrace("%s| Got response from the radio: %s", getName().c_str(), sResult.c_str()); size_t end = sResult.rfind(ICellularRadio::RSP_OK); if (std::string::npos == end) { - printWarning("Unable to get UE Mode Of Operation from radio using command [%s]", sCommand.c_str()); - return CODE::FAILURE; + printError("%s| Unable to get UE Mode Of Operation from radio using command [%s]", getName().c_str(), sCommand.c_str()); + return FAILURE; } const std::string sLabel = "+CEMODE: "; size_t start = sResult.find(sLabel); if (std::string::npos == start) { - printWarning("Unable to get UE Mode Of Operation from radio using command [%s]", sCommand.c_str()); - return CODE::FAILURE; + printError("%s| Unable to get UE Mode Of Operation from radio using command [%s]", getName().c_str(), sCommand.c_str()); + return FAILURE; } start += sLabel.length(); @@ -130,32 +134,32 @@ ICellularRadio::CODE LE910Radio::getUeModeOfOperation(ICellularRadio::UE_MODES_O uint8_t uiValue; if (!MTS::Text::parse(uiValue, sValue)) { - printWarning("Unable to parse CEMODE from response [%s]", sResult.c_str()); - return CODE::FAILURE; + printError("%s| Unable to parse CEMODE from response [%s]", getName().c_str(), sResult.c_str()); + return FAILURE; } CODE rc; switch (uiValue) { case 0: - newmode = ICellularRadio::UE_MODES_OF_OPERATION::PS_MODE2; - rc = CODE::SUCCESS; + mode = UE_MODES_OF_OPERATION::PS_MODE2; + rc = SUCCESS; break; case 1: - newmode = ICellularRadio::UE_MODES_OF_OPERATION::CS_PS_MODE1; - rc = CODE::SUCCESS; + mode = UE_MODES_OF_OPERATION::CS_PS_MODE1; + rc = SUCCESS; break; case 2: - newmode = ICellularRadio::UE_MODES_OF_OPERATION::CS_PS_MODE2; - rc = CODE::SUCCESS; + mode = UE_MODES_OF_OPERATION::CS_PS_MODE2; + rc = SUCCESS; break; case 3: - newmode = ICellularRadio::UE_MODES_OF_OPERATION::PS_MODE1; - rc = CODE::SUCCESS; + mode = UE_MODES_OF_OPERATION::PS_MODE1; + rc = SUCCESS; break; default: - printWarning("Unable to parse CEMODE from response [%s]", sResult.c_str()); - newmode = ICellularRadio::UE_MODES_OF_OPERATION::UNKNOWN_MODE; - rc = CODE::FAILURE; + printError("%s| Unable to parse CEMODE from response [%s]", getName().c_str(), sResult.c_str()); + mode = UE_MODES_OF_OPERATION::UNKNOWN_MODE; + rc = FAILURE; break; } return rc; diff --git a/src/MTS_IO_QuectelRadio.cpp b/src/MTS_IO_QuectelRadio.cpp index 4f20627..7d96627 100644 --- a/src/MTS_IO_QuectelRadio.cpp +++ b/src/MTS_IO_QuectelRadio.cpp @@ -1223,6 +1223,8 @@ ICellularRadio::CODE QuectelRadio::abortFileUpload() { } ICellularRadio::CODE QuectelRadio::setUeModeOfOperation(UE_MODES_OF_OPERATION mode) { + printTrace("%s| Set UE Mode Of Operation", getName().c_str()); + std::string sDomain, sPreference; switch (mode) { @@ -1251,7 +1253,7 @@ ICellularRadio::CODE QuectelRadio::setUeModeOfOperation(UE_MODES_OF_OPERATION mo sPreference = "01"; break; default: - printTrace("Set UE Mode Of Operation: invalid argument"); + printError("%s| Set UE Mode Of Operation: invalid argument", getName().c_str()); return INVALID_ARGS; } @@ -1261,7 +1263,7 @@ ICellularRadio::CODE QuectelRadio::setUeModeOfOperation(UE_MODES_OF_OPERATION mo rc = sendBasicCommand(sCommand, dTimeout); if (rc != SUCCESS) { - printError("Voice/data preference configuration failed with code [%d]", rc); + printError("%s| Voice/data preference configuration failed with code [%d]", getName().c_str(), rc); return rc; } @@ -1269,7 +1271,7 @@ ICellularRadio::CODE QuectelRadio::setUeModeOfOperation(UE_MODES_OF_OPERATION mo rc = sendBasicCommand(sCommand, dTimeout); if (rc != SUCCESS) { - printError("Service domain configuration failed with code [%d]", rc); + printError("%s| Service domain configuration failed with code [%d]", getName().c_str(), rc); return rc; } -- cgit v1.2.3 From ac88b70987f59e89ce5257941e61ad4f1021d65f Mon Sep 17 00:00:00 2001 From: "mykola.salomatin" Date: Fri, 16 Apr 2021 18:50:15 +0300 Subject: [MTX-3998] mPower R. Apr 2021: +CEMODE shall be set to CEMODE=2 - Quectel - GP-1111 Refactoring after review --- include/mts/MTS_IO_CellularRadio.h | 4 +-- include/mts/MTS_IO_ICellularRadio.h | 9 +++---- include/mts/MTS_IO_LE910Radio.h | 4 +-- include/mts/MTS_IO_QuectelRadio.h | 8 +++--- src/MTS_IO_CellularRadio.cpp | 6 ++--- src/MTS_IO_ICellularRadio.cpp | 30 ++++++++++----------- src/MTS_IO_LE910Radio.cpp | 22 ++++++++-------- src/MTS_IO_QuectelRadio.cpp | 52 ++++++++++++++++++------------------- 8 files changed, 67 insertions(+), 68 deletions(-) diff --git a/include/mts/MTS_IO_CellularRadio.h b/include/mts/MTS_IO_CellularRadio.h index b245c48..7e7454b 100644 --- a/include/mts/MTS_IO_CellularRadio.h +++ b/include/mts/MTS_IO_CellularRadio.h @@ -134,8 +134,8 @@ namespace MTS { virtual std::string waitResponse(IsNeedMoreData& isNeedMoreData, int32_t timeoutMillis = 100) override; - CODE setUeModeOfOperation(UE_MODES_OF_OPERATION mode) override; - CODE getUeModeOfOperation(UE_MODES_OF_OPERATION& mode) override; + CODE setUeModeOfOperation(ICellularRadio::UE_MODES_OF_OPERATION mode) override; + CODE getUeModeOfOperation(ICellularRadio::UE_MODES_OF_OPERATION& mode) override; protected: diff --git a/include/mts/MTS_IO_ICellularRadio.h b/include/mts/MTS_IO_ICellularRadio.h index 63cedbe..e638e8b 100644 --- a/include/mts/MTS_IO_ICellularRadio.h +++ b/include/mts/MTS_IO_ICellularRadio.h @@ -82,8 +82,8 @@ namespace MTS { static CODE convertModelToMtsShortCode(const std::string& sModel, std::string& sCode, ICellularRadio *radioObj = NULL); static CODE convertServiceDomainToString(SERVICEDOMAIN eSd, std::string& sSd); static CODE convertActiveBandToString(ACTIVEBAND eBand, std::string& sBand); - static CODE convertUeModeToString(UE_MODES_OF_OPERATION mode, std::string& sMode); - static CODE convertStringToUeMode(const std::string& sMode, UE_MODES_OF_OPERATION& mode); + static CODE convertUeModeToString(ICellularRadio::UE_MODES_OF_OPERATION mode, std::string& sMode); + static CODE convertStringToUeMode(const std::string& sMode, ICellularRadio::UE_MODES_OF_OPERATION& mode); static std::string sendCommand(MTS::AutoPtr& apIo, const std::string& sCmd, @@ -574,9 +574,8 @@ namespace MTS { virtual std::string waitResponse(IsNeedMoreData& isNeedMoreData, int32_t timeoutMillis = 100) = 0; - - virtual CODE setUeModeOfOperation(UE_MODES_OF_OPERATION mode) = 0; - virtual CODE getUeModeOfOperation(UE_MODES_OF_OPERATION& mode) = 0; + virtual CODE setUeModeOfOperation(ICellularRadio::UE_MODES_OF_OPERATION mode) = 0; + virtual CODE getUeModeOfOperation(ICellularRadio::UE_MODES_OF_OPERATION& mode) = 0; }; } } diff --git a/include/mts/MTS_IO_LE910Radio.h b/include/mts/MTS_IO_LE910Radio.h index f64600d..2ba423d 100644 --- a/include/mts/MTS_IO_LE910Radio.h +++ b/include/mts/MTS_IO_LE910Radio.h @@ -45,8 +45,8 @@ namespace MTS { CODE setRxDiversity(const Json::Value& jArgs); CODE getModemLocation(std::string& sLocation); - CODE setUeModeOfOperation(UE_MODES_OF_OPERATION mode) override; - CODE getUeModeOfOperation(UE_MODES_OF_OPERATION& mode) override; + CODE setUeModeOfOperation(ICellularRadio::UE_MODES_OF_OPERATION mode) override; + CODE getUeModeOfOperation(ICellularRadio::UE_MODES_OF_OPERATION& mode) override; protected: diff --git a/include/mts/MTS_IO_QuectelRadio.h b/include/mts/MTS_IO_QuectelRadio.h index 04c0ef9..c46b39b 100644 --- a/include/mts/MTS_IO_QuectelRadio.h +++ b/include/mts/MTS_IO_QuectelRadio.h @@ -51,8 +51,8 @@ namespace MTS { CODE fumoLocalCleanup() override; CODE fumoLocalApply(UpdateCb& stepCb) override; - CODE setUeModeOfOperation(UE_MODES_OF_OPERATION mode) override; - CODE getUeModeOfOperation(UE_MODES_OF_OPERATION& mode) override; + CODE setUeModeOfOperation(ICellularRadio::UE_MODES_OF_OPERATION mode) override; + CODE getUeModeOfOperation(ICellularRadio::UE_MODES_OF_OPERATION& mode) override; protected: enum class UE_USAGE_SETTING : uint8_t { @@ -73,8 +73,8 @@ namespace MTS { virtual CODE removeFile(const std::string& sTargetFilename); virtual CODE checkFile(bool& bFilePresent, const std::string& sTargetFilename); - virtual CODE getUeUsageSetting(UE_USAGE_SETTING& us); - virtual CODE convertToUeUsageSetting(const std::string& sSetting, UE_USAGE_SETTING& us); + virtual CODE getUeUsageSetting(QuectelRadio::UE_USAGE_SETTING& us); + virtual CODE convertToUeUsageSetting(const std::string& sSetting, QuectelRadio::UE_USAGE_SETTING& us); private: // private variable to save old firmware versions during FOTA diff --git a/src/MTS_IO_CellularRadio.cpp b/src/MTS_IO_CellularRadio.cpp index 81e3332..c2fcfad 100644 --- a/src/MTS_IO_CellularRadio.cpp +++ b/src/MTS_IO_CellularRadio.cpp @@ -1379,13 +1379,13 @@ ICellularRadio::CODE CellularRadio::readChunk(int fd, char* pChunk, size_t dChun return rc; } -ICellularRadio::CODE CellularRadio::setUeModeOfOperation(UE_MODES_OF_OPERATION mode) { +ICellularRadio::CODE CellularRadio::setUeModeOfOperation(ICellularRadio::UE_MODES_OF_OPERATION mode) { printTrace("%s| Set UE Mode Of Operation: not applicable", m_sName.c_str()); return NOT_APPLICABLE; } -ICellularRadio::CODE CellularRadio::getUeModeOfOperation(UE_MODES_OF_OPERATION& mode) { +ICellularRadio::CODE CellularRadio::getUeModeOfOperation(ICellularRadio::UE_MODES_OF_OPERATION& mode) { printTrace("%s| Get UE Mode Of Operation: not applicable", m_sName.c_str()); - mode = UE_MODES_OF_OPERATION::UNKNOWN_MODE; + mode = ICellularRadio::UE_MODES_OF_OPERATION::UNKNOWN_MODE; return NOT_APPLICABLE; } diff --git a/src/MTS_IO_ICellularRadio.cpp b/src/MTS_IO_ICellularRadio.cpp index 3394b4e..0483dc8 100644 --- a/src/MTS_IO_ICellularRadio.cpp +++ b/src/MTS_IO_ICellularRadio.cpp @@ -513,30 +513,30 @@ std::string MTS::IO::ICellularRadio::getCodeAsString(CODE eCode) { } } -MTS::IO::ICellularRadio::CODE MTS::IO::ICellularRadio::convertUeModeToString(UE_MODES_OF_OPERATION mode, std::string& sMode) { +MTS::IO::ICellularRadio::CODE MTS::IO::ICellularRadio::convertUeModeToString(ICellularRadio::UE_MODES_OF_OPERATION mode, std::string& sMode) { CODE rc; switch (mode) { - case UE_MODES_OF_OPERATION::PS_MODE1: + case ICellularRadio::UE_MODES_OF_OPERATION::PS_MODE1: sMode = "ps_1"; rc = SUCCESS; break; - case UE_MODES_OF_OPERATION::PS_MODE2: + case ICellularRadio::UE_MODES_OF_OPERATION::PS_MODE2: sMode = "ps_2"; rc = SUCCESS; break; - case UE_MODES_OF_OPERATION::CS_PS_MODE1: + case ICellularRadio::UE_MODES_OF_OPERATION::CS_PS_MODE1: sMode = "csps_1"; rc = SUCCESS; break; - case UE_MODES_OF_OPERATION::CS_PS_MODE2: + case ICellularRadio::UE_MODES_OF_OPERATION::CS_PS_MODE2: sMode = "csps_2"; rc = SUCCESS; break; - case UE_MODES_OF_OPERATION::CS_MODE1: + case ICellularRadio::UE_MODES_OF_OPERATION::CS_MODE1: sMode = "cs_1"; rc = SUCCESS; break; - case UE_MODES_OF_OPERATION::CS_MODE2: + case ICellularRadio::UE_MODES_OF_OPERATION::CS_MODE2: sMode = "cs_2"; rc = SUCCESS; break; @@ -548,28 +548,28 @@ MTS::IO::ICellularRadio::CODE MTS::IO::ICellularRadio::convertUeModeToString(UE_ return rc; } -MTS::IO::ICellularRadio::CODE MTS::IO::ICellularRadio::convertStringToUeMode(const std::string& sMode, UE_MODES_OF_OPERATION& mode) { +MTS::IO::ICellularRadio::CODE MTS::IO::ICellularRadio::convertStringToUeMode(const std::string& sMode, ICellularRadio::UE_MODES_OF_OPERATION& mode) { CODE rc; if (sMode == "ps_1") { - mode = UE_MODES_OF_OPERATION::PS_MODE1; + mode = ICellularRadio::UE_MODES_OF_OPERATION::PS_MODE1; rc = SUCCESS; } else if (sMode == "ps_2") { - mode = UE_MODES_OF_OPERATION::PS_MODE2; + mode = ICellularRadio::UE_MODES_OF_OPERATION::PS_MODE2; rc = SUCCESS; } else if (sMode == "csps_1") { - mode = UE_MODES_OF_OPERATION::CS_PS_MODE1; + mode = ICellularRadio::UE_MODES_OF_OPERATION::CS_PS_MODE1; rc = SUCCESS; } else if (sMode == "csps_2") { - mode = UE_MODES_OF_OPERATION::CS_PS_MODE2; + mode = ICellularRadio::UE_MODES_OF_OPERATION::CS_PS_MODE2; rc = SUCCESS; } else if (sMode == "cs_1") { - mode = UE_MODES_OF_OPERATION::CS_MODE1; + mode = ICellularRadio::UE_MODES_OF_OPERATION::CS_MODE1; rc = SUCCESS; } else if (sMode == "cs_2") { - mode = UE_MODES_OF_OPERATION::CS_MODE2; + mode = ICellularRadio::UE_MODES_OF_OPERATION::CS_MODE2; rc = SUCCESS; } else { - mode = UE_MODES_OF_OPERATION::UNKNOWN_MODE; + mode = ICellularRadio::UE_MODES_OF_OPERATION::UNKNOWN_MODE; rc = FAILURE; } return rc; diff --git a/src/MTS_IO_LE910Radio.cpp b/src/MTS_IO_LE910Radio.cpp index 74cf5c1..ba03c5e 100644 --- a/src/MTS_IO_LE910Radio.cpp +++ b/src/MTS_IO_LE910Radio.cpp @@ -78,22 +78,22 @@ ICellularRadio::CODE LE910Radio::getModemLocation(std::string& sLocation) { return SUCCESS; } -ICellularRadio::CODE LE910Radio::setUeModeOfOperation(UE_MODES_OF_OPERATION mode) { +ICellularRadio::CODE LE910Radio::setUeModeOfOperation(ICellularRadio::UE_MODES_OF_OPERATION mode) { printTrace("%s| Set UE Mode Of Operation", getName().c_str()); std::string sValue; switch (mode) { - case UE_MODES_OF_OPERATION::PS_MODE1: + case ICellularRadio::UE_MODES_OF_OPERATION::PS_MODE1: sValue = "3"; break; - case UE_MODES_OF_OPERATION::PS_MODE2: + case ICellularRadio::UE_MODES_OF_OPERATION::PS_MODE2: sValue = "0"; break; - case UE_MODES_OF_OPERATION::CS_PS_MODE1: + case ICellularRadio::UE_MODES_OF_OPERATION::CS_PS_MODE1: sValue = "1"; break; - case UE_MODES_OF_OPERATION::CS_PS_MODE2: + case ICellularRadio::UE_MODES_OF_OPERATION::CS_PS_MODE2: sValue = "2"; break; default: @@ -107,7 +107,7 @@ ICellularRadio::CODE LE910Radio::setUeModeOfOperation(UE_MODES_OF_OPERATION mode return sendBasicCommand(sCommand, dTimeout); } -ICellularRadio::CODE LE910Radio::getUeModeOfOperation(UE_MODES_OF_OPERATION& mode) { +ICellularRadio::CODE LE910Radio::getUeModeOfOperation(ICellularRadio::UE_MODES_OF_OPERATION& mode) { printTrace("%s| Get UE Mode Of Operation", getName().c_str()); const std::string sCommand = "AT+CEMODE?"; @@ -141,24 +141,24 @@ ICellularRadio::CODE LE910Radio::getUeModeOfOperation(UE_MODES_OF_OPERATION& mod CODE rc; switch (uiValue) { case 0: - mode = UE_MODES_OF_OPERATION::PS_MODE2; + mode = ICellularRadio::UE_MODES_OF_OPERATION::PS_MODE2; rc = SUCCESS; break; case 1: - mode = UE_MODES_OF_OPERATION::CS_PS_MODE1; + mode = ICellularRadio::UE_MODES_OF_OPERATION::CS_PS_MODE1; rc = SUCCESS; break; case 2: - mode = UE_MODES_OF_OPERATION::CS_PS_MODE2; + mode = ICellularRadio::UE_MODES_OF_OPERATION::CS_PS_MODE2; rc = SUCCESS; break; case 3: - mode = UE_MODES_OF_OPERATION::PS_MODE1; + mode = ICellularRadio::UE_MODES_OF_OPERATION::PS_MODE1; rc = SUCCESS; break; default: printError("%s| Unable to parse CEMODE from response [%s]", getName().c_str(), sResult.c_str()); - mode = UE_MODES_OF_OPERATION::UNKNOWN_MODE; + mode = ICellularRadio::UE_MODES_OF_OPERATION::UNKNOWN_MODE; rc = FAILURE; break; } diff --git a/src/MTS_IO_QuectelRadio.cpp b/src/MTS_IO_QuectelRadio.cpp index 7d96627..b6eab80 100644 --- a/src/MTS_IO_QuectelRadio.cpp +++ b/src/MTS_IO_QuectelRadio.cpp @@ -1222,33 +1222,33 @@ ICellularRadio::CODE QuectelRadio::abortFileUpload() { return sendBasicCommand(CMD_ABORT_UPLOAD, 2000, 0x00); } -ICellularRadio::CODE QuectelRadio::setUeModeOfOperation(UE_MODES_OF_OPERATION mode) { +ICellularRadio::CODE QuectelRadio::setUeModeOfOperation(ICellularRadio::UE_MODES_OF_OPERATION mode) { printTrace("%s| Set UE Mode Of Operation", getName().c_str()); std::string sDomain, sPreference; switch (mode) { - case UE_MODES_OF_OPERATION::CS_MODE1: + case ICellularRadio::UE_MODES_OF_OPERATION::CS_MODE1: sDomain = "0"; sPreference = "00"; break; - case UE_MODES_OF_OPERATION::CS_MODE2: + case ICellularRadio::UE_MODES_OF_OPERATION::CS_MODE2: sDomain = "0"; sPreference = "01"; break; - case UE_MODES_OF_OPERATION::PS_MODE1: + case ICellularRadio::UE_MODES_OF_OPERATION::PS_MODE1: sDomain = "1"; sPreference = "00"; break; - case UE_MODES_OF_OPERATION::PS_MODE2: + case ICellularRadio::UE_MODES_OF_OPERATION::PS_MODE2: sDomain = "1"; sPreference = "01"; break; - case UE_MODES_OF_OPERATION::CS_PS_MODE1: + case ICellularRadio::UE_MODES_OF_OPERATION::CS_PS_MODE1: sDomain = "2"; sPreference = "00"; break; - case UE_MODES_OF_OPERATION::CS_PS_MODE2: + case ICellularRadio::UE_MODES_OF_OPERATION::CS_PS_MODE2: sDomain = "2"; sPreference = "01"; break; @@ -1278,7 +1278,7 @@ ICellularRadio::CODE QuectelRadio::setUeModeOfOperation(UE_MODES_OF_OPERATION mo return SUCCESS; } -ICellularRadio::CODE QuectelRadio::getUeUsageSetting(UE_USAGE_SETTING& us) { +ICellularRadio::CODE QuectelRadio::getUeUsageSetting(QuectelRadio::UE_USAGE_SETTING& us) { printTrace("%s| Get UE Usage Setting", getName().c_str()); std::string sCmd("AT+QNVFR=\"/nv/item_files/modem/mmode/ue_usage_setting\""); @@ -1309,22 +1309,22 @@ ICellularRadio::CODE QuectelRadio::getUeUsageSetting(UE_USAGE_SETTING& us) { return SUCCESS; } -ICellularRadio::CODE QuectelRadio::convertToUeUsageSetting(const std::string& sSetting, UE_USAGE_SETTING& us) { +ICellularRadio::CODE QuectelRadio::convertToUeUsageSetting(const std::string& sSetting, QuectelRadio::UE_USAGE_SETTING& us) { if (sSetting == "00") { - us = UE_USAGE_SETTING::MODE_1; + us = QuectelRadio::UE_USAGE_SETTING::MODE_1; return SUCCESS; } if (sSetting == "01") { - us = UE_USAGE_SETTING::MODE_2; + us = QuectelRadio::UE_USAGE_SETTING::MODE_2; return SUCCESS; } - us = UE_USAGE_SETTING::UNKNOWN_MODE; + us = QuectelRadio::UE_USAGE_SETTING::UNKNOWN_MODE; return FAILURE; } -ICellularRadio::CODE QuectelRadio::getUeModeOfOperation(UE_MODES_OF_OPERATION& mode) { +ICellularRadio::CODE QuectelRadio::getUeModeOfOperation(ICellularRadio::UE_MODES_OF_OPERATION& mode) { printTrace("%s| Get UE Mode Of Operation", getName().c_str()); SERVICEDOMAIN sd; @@ -1342,37 +1342,37 @@ ICellularRadio::CODE QuectelRadio::getUeModeOfOperation(UE_MODES_OF_OPERATION& m printTrace("%s| Retrieved ue_usage_setting [%d]", getName().c_str(), us); - if (sd == SERVICEDOMAIN::CS_ONLY && us == UE_USAGE_SETTING::MODE_1) { - mode = UE_MODES_OF_OPERATION::CS_MODE1; + if (sd == ICellularRadio::SERVICEDOMAIN::CS_ONLY && us == QuectelRadio::UE_USAGE_SETTING::MODE_1) { + mode = ICellularRadio::UE_MODES_OF_OPERATION::CS_MODE1; return SUCCESS; } - if (sd == SERVICEDOMAIN::CS_ONLY && us == UE_USAGE_SETTING::MODE_2) { - mode = UE_MODES_OF_OPERATION::CS_MODE2; + if (sd == ICellularRadio::SERVICEDOMAIN::CS_ONLY && us == QuectelRadio::UE_USAGE_SETTING::MODE_2) { + mode = ICellularRadio::UE_MODES_OF_OPERATION::CS_MODE2; return SUCCESS; } - if (sd == SERVICEDOMAIN::PS_ONLY && us == UE_USAGE_SETTING::MODE_1) { - mode = UE_MODES_OF_OPERATION::PS_MODE1; + if (sd == ICellularRadio::SERVICEDOMAIN::PS_ONLY && us == QuectelRadio::UE_USAGE_SETTING::MODE_1) { + mode = ICellularRadio::UE_MODES_OF_OPERATION::PS_MODE1; return SUCCESS; } - if (sd == SERVICEDOMAIN::PS_ONLY && us == UE_USAGE_SETTING::MODE_2) { - mode = UE_MODES_OF_OPERATION::PS_MODE2; + if (sd == ICellularRadio::SERVICEDOMAIN::PS_ONLY && us == QuectelRadio::UE_USAGE_SETTING::MODE_2) { + mode = ICellularRadio::UE_MODES_OF_OPERATION::PS_MODE2; return SUCCESS; } - if (sd == SERVICEDOMAIN::CSPS && us == UE_USAGE_SETTING::MODE_1) { - mode = UE_MODES_OF_OPERATION::CS_PS_MODE1; + if (sd == ICellularRadio::SERVICEDOMAIN::CSPS && us == QuectelRadio::UE_USAGE_SETTING::MODE_1) { + mode = ICellularRadio::UE_MODES_OF_OPERATION::CS_PS_MODE1; return SUCCESS; } - if (sd == SERVICEDOMAIN::CSPS && us == UE_USAGE_SETTING::MODE_2) { - mode = UE_MODES_OF_OPERATION::CS_PS_MODE2; + if (sd == ICellularRadio::SERVICEDOMAIN::CSPS && us == QuectelRadio::UE_USAGE_SETTING::MODE_2) { + mode = ICellularRadio::UE_MODES_OF_OPERATION::CS_PS_MODE2; return SUCCESS; } printError("%s| Unknown combination of servicedomain [%d] and ue_usage_setting [%d]", getName().c_str(), sd, us); - mode = UE_MODES_OF_OPERATION::UNKNOWN_MODE; + mode = ICellularRadio::UE_MODES_OF_OPERATION::UNKNOWN_MODE; return FAILURE; } -- cgit v1.2.3