diff options
38 files changed, 2341 insertions, 0 deletions
diff --git a/CommandTerminal/CmdAttention.cpp b/CommandTerminal/CmdAttention.cpp new file mode 100644 index 0000000..892e891 --- /dev/null +++ b/CommandTerminal/CmdAttention.cpp @@ -0,0 +1,16 @@ +#include "CmdAttention.h" + +CmdAttention::CmdAttention(mDot* dot) : Command(dot, "Attention", "AT", "Attention") +{ + _help = std::string(text()) + ": " + std::string(desc()); +} + +CmdAttention::CmdAttention(mDot* dot, const char* name, const char* text, const char* desc) : Command(dot, name, text, desc) +{ + +} + +uint32_t CmdAttention::action(std::vector<std::string> args) { + return 0; +} + diff --git a/CommandTerminal/CmdAttention.h b/CommandTerminal/CmdAttention.h new file mode 100644 index 0000000..76fd1d2 --- /dev/null +++ b/CommandTerminal/CmdAttention.h @@ -0,0 +1,17 @@ +#ifndef __CMDATTENTION_H__ +#define __CMDATTENTION_H__ + +#include "Command.h" + +class CmdAttention : public Command { + +public: + + CmdAttention(mDot* dot); + CmdAttention(mDot* dot, const char* name, const char* text, const char* desc); + virtual uint32_t action(std::vector<std::string> args); + +private: +}; + +#endif // __CMDATTENTION_H__ diff --git a/CommandTerminal/CmdDataSessionKey.cpp b/CommandTerminal/CmdDataSessionKey.cpp new file mode 100644 index 0000000..d663406 --- /dev/null +++ b/CommandTerminal/CmdDataSessionKey.cpp @@ -0,0 +1,56 @@ +#include "CmdDataSessionKey.h" + +CmdDataSessionKey::CmdDataSessionKey(mDot* dot, mts::MTSSerial& serial) : + Command(dot, "Data Session Key", "AT+DSK", "Data session encryption key (16 bytes)"), _serial(serial) +{ + _help = std::string(text()) + ": " + std::string(desc()); + _usage = "(hex:16)"; + _queryable = true; +} + +uint32_t CmdDataSessionKey::action(std::vector<std::string> args) +{ + if (args.size() == 1) + { + if (_dot->getVerbose()) + _serial.writef("Data Session Key: "); + _serial.writef("%s\r\n", mts::Text::bin2hexString(_dot->getDataSessionKey(), ".").c_str()); + } + else if (args.size() == 2) + { + int32_t code; + std::vector<uint8_t> NewKey; + + // Read in the key components... + readByteArray(args[1], NewKey, KEY_LENGTH); + + if ((code = _dot->setDataSessionKey(NewKey)) == mDot::MDOT_OK) { + _serial.writef("Set Data Session Key: "); + _serial.writef("%s\r\n", mts::Text::bin2hexString(NewKey, ".").c_str()); + } else { + std::string error = mDot::getReturnCodeString(code) + " - " + _dot->getLastError(); + setErrorMessage(error); + return 1; + } + } + + return 0; +} + +bool CmdDataSessionKey::verify(std::vector<std::string> args) +{ + if (args.size() == 1) + return true; + + if (args.size() == 2) { + if (!isHexString(args[1], 16)) { + setErrorMessage("Invalid key, expects (hex:16)"); + return false; + } + + return true; + } + + setErrorMessage("Invalid arguments"); + return false; +} diff --git a/CommandTerminal/CmdDataSessionKey.h b/CommandTerminal/CmdDataSessionKey.h new file mode 100644 index 0000000..704af6e --- /dev/null +++ b/CommandTerminal/CmdDataSessionKey.h @@ -0,0 +1,20 @@ +#ifndef __CMDDATASESSIONKEY_H__ +#define __CMDDATASESSIONKEY_H__ + +#include "Command.h" + +class CommandTerminal; + +class CmdDataSessionKey : public Command { + +public: + + CmdDataSessionKey(mDot* dot, mts::MTSSerial& serial); + virtual uint32_t action(std::vector<std::string> args); + virtual bool verify(std::vector<std::string> args); + +private: + mts::MTSSerial& _serial; +}; + +#endif // __CMDDATASESSIONKEY_H__ diff --git a/CommandTerminal/CmdDeviceId.cpp b/CommandTerminal/CmdDeviceId.cpp new file mode 100644 index 0000000..05d2301 --- /dev/null +++ b/CommandTerminal/CmdDeviceId.cpp @@ -0,0 +1,57 @@ +#include "CmdDeviceId.h" +#include <algorithm> + +CmdDeviceId::CmdDeviceId(mDot* dot, mts::MTSSerial& serial) : + Command(dot, "Device ID", "AT+DI", "Device EUI (unique, set at factory) (8 bytes)"), _serial(serial) +{ + _help = std::string(text()) + ": " + std::string(desc()); + _usage = "(hex:8)"; + _queryable = true; +} + +uint32_t CmdDeviceId::action(std::vector<std::string> args) +{ + if (args.size() == 1) + { + if (_dot->getVerbose()) + _serial.writef("%s: ", name()); + _serial.writef("%s\r\n", mts::Text::bin2hexString(_dot->getDeviceId(), ":").c_str()); + } +#ifdef DEBUG_MAC + else if (args.size() == 2) + { + int32_t code; + std::vector<uint8_t> NewEUI; + + // Read in the key components... + readByteArray(args[1], NewEUI, EUI_LENGTH); + + if ((code = _dot->setDeviceId(NewEUI)) == mDot::MDOT_OK) { + _serial.writef("Set %s: ", name()); + _serial.writef("%s\r\n", mts::Text::bin2hexString(NewEUI, ":").c_str()); + } else { + std::string error = mDot::getReturnCodeString(code) + " - " + _dot->getLastError(); + setErrorMessage(error); + return 1; + } + } +#endif + return 0; +} + +bool CmdDeviceId::verify(std::vector<std::string> args) +{ + if (args.size() == 1) + return true; + +#ifdef DEBUG_MAC + if (args.size() == 2 && isHexString(args[1], 8)) + return true; + + setErrorMessage("Invalid id, expects (hex:8)"); +#else + setErrorMessage("Invalid arguments"); +#endif + + return false; +} diff --git a/CommandTerminal/CmdDeviceId.h b/CommandTerminal/CmdDeviceId.h new file mode 100644 index 0000000..9e1ad74 --- /dev/null +++ b/CommandTerminal/CmdDeviceId.h @@ -0,0 +1,21 @@ +#ifndef __CMDDEVICEID_H__ +#define __CMDDEVICEID_H__ + +#include "Command.h" + +class CommandTerminal; + +class CmdDeviceId : public Command { + +public: + + CmdDeviceId(mDot* dot, mts::MTSSerial& serial); + virtual uint32_t action(std::vector<std::string> args); + virtual bool verify(std::vector<std::string> args); + +private: + + mts::MTSSerial& _serial; +}; + +#endif // __CMDDEVICEID_H__ diff --git a/CommandTerminal/CmdDisplayConfig.cpp b/CommandTerminal/CmdDisplayConfig.cpp new file mode 100644 index 0000000..6ef6e92 --- /dev/null +++ b/CommandTerminal/CmdDisplayConfig.cpp @@ -0,0 +1,106 @@ +#include "CmdDisplayConfig.h" + +CmdDisplayConfig::CmdDisplayConfig(mDot* dot, mts::MTSSerial& serial) +: + Command(dot, "Display Settings", "AT&V", "Displays current settings and status"), + _serial(serial) { + _help = std::string(text()) + ": " + std::string(desc()); + _usage = "TABLE"; +} + +uint32_t CmdDisplayConfig::action(std::vector<std::string> args) { + _serial.writef("Device ID:\t\t"); + _serial.writef("%s\r\n", mts::Text::bin2hexString(_dot->getDeviceId(), ":").c_str()); + + _serial.writef("Frequency Band:\t\t%s\r\n", mDot::FrequencyBandStr(_dot->getFrequencyBand()).c_str()); + _serial.writef("Frequency Sub Band:\t%u\r\n", _dot->getFrequencySubBand()); + + _serial.writef("Public Network:\t\t%s\r\n", _dot->getPublicNetwork() ? "on" : "off"); + _serial.writef("Start Up Mode:\t\t%s\r\n", mDot::ModeStr(_dot->getStartUpMode()).c_str()); + + _serial.writef("Network Address:\t%s\r\n", mts::Text::bin2hexString(_dot->getNetworkAddress()).c_str()); + + _serial.writef("Network ID:\t\t"); + _serial.writef("%s\r\n", mts::Text::bin2hexString(_dot->getNetworkId(), ":").c_str()); + + _serial.writef("Network ID Passphrase:\t%s\r\n", _dot->getNetworkName().c_str()); + + _serial.writef("Network Key:\t\t"); + _serial.writef("%s\r\n", mts::Text::bin2hexString(_dot->getNetworkKey(), ".").c_str()); + + _serial.writef("Network Key Passphrase:\t%s\r\n", _dot->getNetworkPassphrase().c_str()); + + _serial.writef("Network Session Key:\t"); + _serial.writef("%s\r\n", mts::Text::bin2hexString(_dot->getNetworkSessionKey(), ".").c_str()); + + _serial.writef("Data Session Key:\t"); + _serial.writef("%s\r\n", mts::Text::bin2hexString(_dot->getDataSessionKey(), ".").c_str()); + + _serial.writef("Network Join Mode:\t%s\r\n", mDot::JoinModeStr(_dot->getJoinMode()).c_str()); + + _serial.writef("Network Join Retries:\t%u\r\n", _dot->getJoinRetries()); + + _serial.writef("Join Byte Order:\t%s\r\n", _dot->getJoinByteOrder() ? "MSB" : "LSB"); + + _serial.writef("Link Check Threshold:\t"); + if (_dot->getLinkCheckThreshold() == 0) { + _serial.writef("off\r\n"); + } else { + _serial.writef("%lu\r\n", _dot->getLinkCheckThreshold()); + } + + _serial.writef("Link Check Count:\t"); + if (_dot->getLinkCheckCount() == 0) { + _serial.writef("off\r\n"); + } else { + _serial.writef("%lu packets\r\n", _dot->getLinkCheckCount()); + } + + _serial.writef("Error Correction:\t"); + if (_dot->getFec() == 0) { + _serial.writef("off\r\n"); + } else { + _serial.writef("%u bytes\r\n", _dot->getFec()); + } + + _serial.writef("ACK Retries:\t\t"); + if (_dot->getAck() == 0) { + _serial.writef("off\r\n"); + } else { + _serial.writef("%u\r\n", _dot->getAck()); + } + + _serial.writef("Encryption:\t\t%s\r\n", _dot->getAesEncryption() ? "on" : "off"); + _serial.writef("CRC:\t\t\t%s\r\n", _dot->getCrc() ? "on" : "off"); + _serial.writef("Adaptive Data Rate:\t%s\r\n", _dot->getAdr() ? "on" : "off"); + _serial.writef("Command Echo:\t\t%s\r\n", _dot->getEcho() ? "on" : "off"); + _serial.writef("Verbose Response:\t%s\r\n", _dot->getVerbose() ? "on" : "off"); + + _serial.writef("Tx Frequency:\t\t%lu\r\n", _dot->getTxFrequency()); + _serial.writef("Tx Data Rate:\t\t%s\r\n", mDot::DataRateStr(_dot->getTxDataRate()).c_str()); + _serial.writef("Tx Power:\t\t%u\r\n", _dot->getTxPower()); + _serial.writef("Tx Wait:\t\t%s\r\n", _dot->getTxWait() ? "on" : "off"); + + _serial.writef("Tx Inverted Signal:\t%s\r\n", _dot->getTxInverted() ? "on" : "off"); + + _serial.writef("Rx Frequency:\t\t%lu\r\n", _dot->getRxFrequency()); + _serial.writef("Rx Data Rate:\t\t%s\r\n", mDot::DataRateStr(_dot->getRxDataRate()).c_str()); + _serial.writef("Rx Inverted Signal:\t%s\r\n", _dot->getRxInverted() ? "on" : "off"); + + _serial.writef("Rx Output Style:\t%s\r\n", mDot::RxOutputStr(_dot->getRxOutput()).c_str()); + + _serial.writef("Debug Baud Rate:\t%lu\r\n", _dot->getDebugBaud()); + _serial.writef("Serial Baud Rate:\t%lu\r\n", _dot->getBaud()); + + _serial.writef("Wake Mode:\t\t%s\r\n", _dot->getWakeMode() == 0 ? "INTERVAL" : "INTERRUPT"); + _serial.writef("Wake Interval:\t\t%lu s\r\n", _dot->getWakeInterval()); + _serial.writef("Wake Delay:\t\t%lu ms\r\n", _dot->getWakeDelay()); + _serial.writef("Wake Timeout:\t\t%u ms\r\n", _dot->getWakeTimeout()); + + //_serial.writef("Wake Pin:\t\t%s\r\n", mDot::pinName2Str(_dot->getWakePin()).c_str()); + + _serial.writef("Log Level:\t\t%ld\r\n", _dot->getLogLevel()); + + return 0; +} + diff --git a/CommandTerminal/CmdDisplayConfig.h b/CommandTerminal/CmdDisplayConfig.h new file mode 100644 index 0000000..05e7ac9 --- /dev/null +++ b/CommandTerminal/CmdDisplayConfig.h @@ -0,0 +1,19 @@ +#ifndef __CMDDISPLAYCONFIG_H__ +#define __CMDDISPLAYCONFIG_H__ + +#include "Command.h" + +class CmdDisplayConfig : public Command { + +public: + + CmdDisplayConfig(mDot* dot, mts::MTSSerial& serial); + virtual uint32_t action(std::vector<std::string> args); + +private: + + mts::MTSSerial& _serial; + +}; + +#endif // __CMDDISPLAYCONFIG_H__ diff --git a/CommandTerminal/CmdFactoryDefault.cpp b/CommandTerminal/CmdFactoryDefault.cpp new file mode 100644 index 0000000..53b6ede --- /dev/null +++ b/CommandTerminal/CmdFactoryDefault.cpp @@ -0,0 +1,15 @@ +#include "CmdFactoryDefault.h" + +CmdFactoryDefault::CmdFactoryDefault(mDot* dot) : Command(dot, "Reset Factory Defaults", "AT&F", "Reset current configuration to factory defaults") +{ + _help = std::string(text()) + ": " + std::string(desc()); +} + + +uint32_t CmdFactoryDefault::action(std::vector<std::string> args) +{ + _dot->resetConfig(); + _dot->resetNetworkSession(); + return 0; +} + diff --git a/CommandTerminal/CmdFactoryDefault.h b/CommandTerminal/CmdFactoryDefault.h new file mode 100644 index 0000000..8957ae3 --- /dev/null +++ b/CommandTerminal/CmdFactoryDefault.h @@ -0,0 +1,16 @@ +#ifndef __CmdFactoryDefault_H__ +#define __CmdFactoryDefault_H__ + +#include "Command.h" + +class CmdFactoryDefault : public Command { + +public: + + CmdFactoryDefault(mDot* dot); + virtual uint32_t action(std::vector<std::string> args); + +private: +}; + +#endif // __CmdFactoryDefault_H__ diff --git a/CommandTerminal/CmdFrequencySubBand.cpp b/CommandTerminal/CmdFrequencySubBand.cpp new file mode 100644 index 0000000..fb9f0ba --- /dev/null +++ b/CommandTerminal/CmdFrequencySubBand.cpp @@ -0,0 +1,60 @@ +#include "CmdFrequencySubBand.h" + +CmdFrequencySubBand::CmdFrequencySubBand(mDot* dot, mts::MTSSerial& serial) : + Command(dot, "Frequency Sub-band", "AT+FSB", "Set the frequency sub-band for US 915, (0:ALL, 1-8)"), _serial(serial) +{ + _help = std::string(text()) + ": " + std::string(desc()); + _usage = "(0-8)"; + _queryable = true; +} + +uint32_t CmdFrequencySubBand::action(std::vector<std::string> args) +{ + + if (args.size() == 1) + { + if (_dot->getVerbose()) + _serial.writef("Frequency Sub Band: "); + + _serial.writef("%u\r\n", _dot->getFrequencySubBand()); + } + else if (args.size() == 2) + { + int32_t code; + uint32_t band; + sscanf(args[1].c_str(), "%lu", &band); + + if ((code = _dot->setFrequencySubBand(band)) != mDot::MDOT_OK) { + std::string error = mDot::getReturnCodeString(code) + " - " + _dot->getLastError(); + setErrorMessage(error); + return 1; + } + } + + return 0; +} + +bool CmdFrequencySubBand::verify(std::vector<std::string> args) +{ + if (args.size() == 1) + return true; + + if (args.size() == 2) + { + uint32_t band; + if (sscanf(args[1].c_str(), "%u", &band) != 1) { + setErrorMessage("Invalid arguments"); + return false; + } + + if (band < mDot::FSB_ALL || band > mDot::FSB_8) { + setErrorMessage("Invalid channel band, expects (0-8)"); + return false; + } + + return true; + } + + setErrorMessage("Invalid arguments"); + return false; +} diff --git a/CommandTerminal/CmdFrequencySubBand.h b/CommandTerminal/CmdFrequencySubBand.h new file mode 100644 index 0000000..14d50c9 --- /dev/null +++ b/CommandTerminal/CmdFrequencySubBand.h @@ -0,0 +1,20 @@ +#ifndef __CMDFREQUENCYSUBBAND_H__ +#define __CMDFREQUENCYSUBBAND_H__ + +#include "Command.h" + +class CommandTerminal; + +class CmdFrequencySubBand : public Command { + +public: + + CmdFrequencySubBand(mDot* dot, mts::MTSSerial& serial); + virtual uint32_t action(std::vector<std::string> args); + virtual bool verify(std::vector<std::string> args); + +private: + mts::MTSSerial& _serial; +}; + +#endif // __CMDFREQUENCYSUBBAND_H__ diff --git a/CommandTerminal/CmdIdentification.cpp b/CommandTerminal/CmdIdentification.cpp new file mode 100644 index 0000000..a765b30 --- /dev/null +++ b/CommandTerminal/CmdIdentification.cpp @@ -0,0 +1,20 @@ +#include "CmdIdentification.h" +#include "version.h" + +CmdIdentification::CmdIdentification(mDot* dot, mts::MTSSerial& serial) : Command(dot, "Request Id", "ATI", "Request Identification"), _serial(serial) +{ + _help = std::string(text()) + ": " + std::string(desc()); +} + +uint32_t CmdIdentification::action(std::vector<std::string> args) +{ + std::string version = MTDOT_BOX_VERSION; +#ifdef DEBUG_MAC + version += "-debug"; +#endif + _serial.writef("MultiTech mDot\r\n"); + _serial.writef("Firmware: %s\r\n", version.c_str()); + _serial.writef("Library : %s\r\n", _dot->getId().c_str()); + + return 0; +} diff --git a/CommandTerminal/CmdIdentification.h b/CommandTerminal/CmdIdentification.h new file mode 100644 index 0000000..b553ba1 --- /dev/null +++ b/CommandTerminal/CmdIdentification.h @@ -0,0 +1,17 @@ +#ifndef __CMDIDENTIFICATION_H__ +#define __CMDIDENTIFICATION_H__ + +#include "Command.h" + +class CmdIdentification : public Command { + +public: + + CmdIdentification(mDot* dot, mts::MTSSerial& serial); + virtual uint32_t action(std::vector<std::string> args); + +private: + mts::MTSSerial& _serial; +}; + +#endif // __CMDIDENTIFICATION_H__ diff --git a/CommandTerminal/CmdNetworkAddress.cpp b/CommandTerminal/CmdNetworkAddress.cpp new file mode 100644 index 0000000..07c0591 --- /dev/null +++ b/CommandTerminal/CmdNetworkAddress.cpp @@ -0,0 +1,72 @@ +#include "CmdNetworkAddress.h" +#include <algorithm> + +CmdNetworkAddress::CmdNetworkAddress(mDot* dot, mts::MTSSerial& serial) : + Command(dot, "Network Address", "AT+NA", "Network address (devAddr in LoraMac) (4 bytes)"), _serial(serial) +{ + _help = std::string(text()) + ": " + std::string(desc()); + _usage = "(hex:4)"; + _queryable = true; +} + +uint32_t CmdNetworkAddress::action(std::vector<std::string> args) +{ + std::vector<uint8_t> addr; + + if (args.size() == 1) + { + if (_dot->getVerbose()) + _serial.writef("Network Address: "); + + addr = _dot->getNetworkAddress(); + + _serial.writef("%02x:%02x:%02x:%02x\r\n", addr[0], addr[1], addr[2], addr[3]); + } + else if (args.size() == 2) + { + int32_t code; + uint8_t temp; + uint32_t step = 2; + + if (args[1].find(":") != std::string::npos || args[1].find(".") != std::string::npos || args[1].find("-") != std::string::npos) + step = 3; + + // Convert the ASCII hex data to binary... + for (size_t i = 0; i < args[1].size(); i += step) + { + sscanf(&args[1][i], "%02x", &temp); + addr.push_back(temp); + } + + if ((code = _dot->setNetworkAddress(addr)) == mDot::MDOT_OK) { + _serial.writef("Set Network Address: "); + _serial.writef("%02x:%02x:%02x:%02x\r\n", addr[0], addr[1], addr[2], addr[3]); + } else { + std::string error = mDot::getReturnCodeString(code) + " - " + _dot->getLastError(); + setErrorMessage(error); + return 1; + } + } + + return 0; +} + +bool CmdNetworkAddress::verify(std::vector<std::string> args) +{ + if (args.size() == 1) { + return true; + } + + if (args.size() == 2) { + if (!isHexString(args[1], 4)) + { + setErrorMessage("Invalid address, expects (hex:4)"); + return false; + } + + return true; + } + + setErrorMessage("Invalid arguments"); + return false; +} diff --git a/CommandTerminal/CmdNetworkAddress.h b/CommandTerminal/CmdNetworkAddress.h new file mode 100644 index 0000000..7be2dd0 --- /dev/null +++ b/CommandTerminal/CmdNetworkAddress.h @@ -0,0 +1,20 @@ +#ifndef __CMDNETWORKADDRESS_H__ +#define __CMDNETWORKADDRESS_H__ + +#include "Command.h" + +class CommandTerminal; + +class CmdNetworkAddress : public Command { + +public: + + CmdNetworkAddress(mDot* dot, mts::MTSSerial& serial); + virtual uint32_t action(std::vector<std::string> args); + virtual bool verify(std::vector<std::string> args); + +private: + mts::MTSSerial& _serial; +}; + +#endif // __CMDNETWORKADDRESS_H__ diff --git a/CommandTerminal/CmdNetworkId.cpp b/CommandTerminal/CmdNetworkId.cpp new file mode 100644 index 0000000..fffe9f7 --- /dev/null +++ b/CommandTerminal/CmdNetworkId.cpp @@ -0,0 +1,110 @@ +#include "CmdNetworkId.h" + +CmdNetworkId::CmdNetworkId(mDot* dot, mts::MTSSerial& serial) : + Command(dot, "Network ID", "AT+NI", "Configured Network EUI/Name (App EUI in LoraMac) AT+NI=0,hex AT+NI=1,network_name (Net ID = crc64(network_name)) (8 bytes)"), + _serial(serial) +{ + _help = std::string(text()) + ": " + std::string(desc()); + _usage = "(0,(hex:8)),(1,(string:128))"; + _queryable = true; +} + +uint32_t CmdNetworkId::action(std::vector<std::string> args) +{ + if (args.size() == 1) + { + if (_dot->getVerbose()) + _serial.writef("Network ID: "); + + _serial.writef("%s\r\n", mts::Text::bin2hexString(_dot->getNetworkId(), ":").c_str()); + + if (!_dot->getNetworkName().empty()) + _serial.writef("Passphrase: '%s'\r\n", _dot->getNetworkName().c_str()); + } + else + { + int32_t code; + + if (args[1].find("1") == 0 && args[1].size() == 1) + { + std::string text; + if (args.size() > 3) + { + // passphrase was split on commas + for (size_t i = 2; i < args.size(); i++) + { + text.append(args[i]); + if (i < args.size() - 1) + text.append(","); + } + } + else + { + text = args[2]; + } + + if ((code = _dot->setNetworkName(text)) == mDot::MDOT_OK) + { + _serial.writef("Set Network Name: "); + _serial.writef("%s\r\n", text.c_str()); + } + else + { + std::string error = mDot::getReturnCodeString(code) + " - " + _dot->getLastError(); + setErrorMessage(error); + return 1; + } + + } + else + { + std::vector<uint8_t> NewKey; + readByteArray(args[2], NewKey, EUI_LENGTH); + if ((code = _dot->setNetworkId(NewKey)) == mDot::MDOT_OK) + { + _serial.writef("Set Network ID: "); + _serial.writef("%s\r\n", mts::Text::bin2hexString(NewKey, ".").c_str()); + } + else + { + std::string error = mDot::getReturnCodeString(code) + " - " + _dot->getLastError(); + setErrorMessage(error); + return 1; + } + } + } + + return 0; +} + +bool CmdNetworkId::verify(std::vector<std::string> args) +{ + if (args.size() == 1) + return true; + + if (args.size() == 3) { + if (args[1] != "0" && args[1] != "1") { + setErrorMessage("Invalid type, expects (0,1)"); + return false; + } + if (args[1] == "0" && !isHexString(args[2], 8)) { + setErrorMessage("Invalid ID, expects (hex:8"); + return false; + } + + if (args[1] == "1" && args[2].size() < 8) { + setErrorMessage("Invalid name, expects minimum 8 characters"); + return false; + } + + if (args[1] == "1" && args[2].size() > 128) { + setErrorMessage("Invalid name, expects (string:128)"); + return false; + } + + return true; + } + + setErrorMessage("Invalid arguments"); + return false; +} diff --git a/CommandTerminal/CmdNetworkId.h b/CommandTerminal/CmdNetworkId.h new file mode 100644 index 0000000..09acdc6 --- /dev/null +++ b/CommandTerminal/CmdNetworkId.h @@ -0,0 +1,20 @@ +#ifndef __CMDNETWORKID_H__ +#define __CMDNETWORKID_H__ + +#include "Command.h" + +class CommandTerminal; + +class CmdNetworkId : public Command { + +public: + + CmdNetworkId(mDot* dot, mts::MTSSerial& serial); + virtual uint32_t action(std::vector<std::string> args); + virtual bool verify(std::vector<std::string> args); + +private: + mts::MTSSerial& _serial; +}; + +#endif // __CMDNETWORKID_H__ diff --git a/CommandTerminal/CmdNetworkJoinMode.cpp b/CommandTerminal/CmdNetworkJoinMode.cpp new file mode 100644 index 0000000..b5efdf6 --- /dev/null +++ b/CommandTerminal/CmdNetworkJoinMode.cpp @@ -0,0 +1,55 @@ +#include "CmdNetworkJoinMode.h" + +CmdNetworkJoinMode::CmdNetworkJoinMode(mDot* dot, mts::MTSSerial& serial) : + Command(dot, "Network Join Mode", "AT+NJM", "0: Manual configuration, 1: OTA Network Join, 2: Auto OTA Network Join on start up (default: 1)"), + _serial(serial) +{ + _help = std::string(text()) + ": " + std::string(desc()); + _usage = "(0-2)"; + _queryable = true; +} + +uint32_t CmdNetworkJoinMode::action(std::vector<std::string> args) +{ + if (args.size() == 1) + { + if (_dot->getVerbose()) + _serial.writef("%s: ", name()); + + _serial.writef("%u\r\n", _dot->getJoinMode()); + } + else if (args.size() == 2) + { + int32_t code; + uint8_t mode = (args[1] == "1") ? 1 : 0; + mode = (args[1] == "2" ? 2 : mode); + if ((code = _dot->setJoinMode(mode)) != mDot::MDOT_OK) + { + std::string error = mDot::getReturnCodeString(code) + " - " + _dot->getLastError(); + setErrorMessage(error); + return 1; + } + } + + return 0; +} + +bool CmdNetworkJoinMode::verify(std::vector<std::string> args) +{ + if (args.size() == 1) + return true; + + if (args.size() == 2) + { + if (!(args[1] == "0" || args[1] == "1" || args[1] == "2")) + { + setErrorMessage("Invalid parameter, expects (0: Manual, 1: OTA, 2: Auto OTA)"); + return false; + } + + return true; + } + + setErrorMessage("Invalid arguments"); + return false; +} diff --git a/CommandTerminal/CmdNetworkJoinMode.h b/CommandTerminal/CmdNetworkJoinMode.h new file mode 100644 index 0000000..81d00d0 --- /dev/null +++ b/CommandTerminal/CmdNetworkJoinMode.h @@ -0,0 +1,20 @@ +#ifndef __CMDNETWORKJOINMODE_H__ +#define __CMDNETWORKJOINMODE_H__ + +#include "Command.h" + +class CommandTerminal; + +class CmdNetworkJoinMode : public Command { + +public: + + CmdNetworkJoinMode(mDot* dot, mts::MTSSerial& serial); + virtual uint32_t action(std::vector<std::string> args); + virtual bool verify(std::vector<std::string> args); + +private: + mts::MTSSerial& _serial; +}; + +#endif // __CMDNETWORKJOINMODE_H__ diff --git a/CommandTerminal/CmdNetworkKey.cpp b/CommandTerminal/CmdNetworkKey.cpp new file mode 100644 index 0000000..f85725c --- /dev/null +++ b/CommandTerminal/CmdNetworkKey.cpp @@ -0,0 +1,110 @@ +#include "CmdNetworkKey.h" + +CmdNetworkKey::CmdNetworkKey(mDot* dot, mts::MTSSerial& serial) : + Command(dot, "Network Key", "AT+NK", "Configured network key/passphrase (App Key in LoraMac) ## AT+NK=0,hex AT+NK=1,passphrase (Net key = cmac(passphrase)) (16 bytes)"), + _serial(serial) +{ + _help = std::string(text()) + ": " + std::string(desc()); + _usage = "(0,(hex:16)),(1,(string:128))"; + _queryable = true; +} + +uint32_t CmdNetworkKey::action(std::vector<std::string> args) +{ + if (args.size() == 1) + { + if (_dot->getVerbose()) + _serial.writef("Network Key: "); + + _serial.writef("%s\r\n", mts::Text::bin2hexString(_dot->getNetworkKey(), ".").c_str()); + if (!_dot->getNetworkPassphrase().empty()) + _serial.writef("Passphrase: '%s'\r\n", _dot->getNetworkPassphrase().c_str()); + + } + else if (args.size() == 3) + { + int32_t code; + + if (args[1].find("1") == 0 && args[1].size() == 1) + { + std::string text; + if (args.size() > 3) + { + // passphrase was split on commas + for (size_t i = 2; i < args.size(); i++) + { + text.append(args[i]); + if (i < args.size() - 1) + text.append(","); + } + } + else + { + text = args[2]; + } + + if ((code = _dot->setNetworkPassphrase(text)) == mDot::MDOT_OK) + { + _serial.writef("Set Network Passphrase: "); + _serial.writef("%s\r\n", text.c_str()); + } + else + { + std::string error = mDot::getReturnCodeString(code) + " - " + _dot->getLastError(); + setErrorMessage(error); + return 1; + } + } + else + { + std::vector<uint8_t> NewKey; + readByteArray(args[2], NewKey, KEY_LENGTH); + if ((code = _dot->setNetworkKey(NewKey)) == mDot::MDOT_OK) + { + _serial.writef("Set Network Key: "); + _serial.writef("%s\r\n", mts::Text::bin2hexString(NewKey, ".").c_str()); + } + else + { + std::string error = mDot::getReturnCodeString(code) + " - " + _dot->getLastError(); + setErrorMessage(error); + return 1; + } + } + } + + return 0; +} + +bool CmdNetworkKey::verify(std::vector<std::string> args) +{ + if (args.size() == 1) + return true; + + if (args.size() == 3) { + if (args[1] != "0" && args[1] != "1") { + setErrorMessage("Invalid type, expects (0,1)"); + return false; + } + if (args[1] == "0" && !isHexString(args[2], 16)) { + setErrorMessage("Invalid key, expects (hex:16)"); + return false; + } + + if (args[1] == "1" && args[2].size() < 8) { + setErrorMessage("Invalid name, expects minimum 8 characters"); + return false; + } + + if (args[1] == "1" && (args[2].size() > 128 || args[2].size() < 8)) { + setErrorMessage("Invalid passphrase, expects (string:8-128)"); + return false; + } + + return true; + } + + setErrorMessage("Invalid arguments"); + return false; +} + diff --git a/CommandTerminal/CmdNetworkKey.h b/CommandTerminal/CmdNetworkKey.h new file mode 100644 index 0000000..f2874cc --- /dev/null +++ b/CommandTerminal/CmdNetworkKey.h @@ -0,0 +1,22 @@ + +#ifndef __CMDNETWORKKEY_H__ +#define __CMDNETWORKKEY_H__ + + +#include "Command.h" + +class CommandTerminal; + +class CmdNetworkKey : public Command { + +public: + + CmdNetworkKey(mDot* dot, mts::MTSSerial& serial); + virtual uint32_t action(std::vector<std::string> args); + virtual bool verify(std::vector<std::string> args); + +private: + mts::MTSSerial& _serial; +}; + +#endif // __CMDNETWORKKEY_H__ diff --git a/CommandTerminal/CmdNetworkSessionKey.cpp b/CommandTerminal/CmdNetworkSessionKey.cpp new file mode 100644 index 0000000..4d42505 --- /dev/null +++ b/CommandTerminal/CmdNetworkSessionKey.cpp @@ -0,0 +1,57 @@ +#include "CmdNetworkSessionKey.h" + +CmdNetworkSessionKey::CmdNetworkSessionKey(mDot* dot, mts::MTSSerial& serial) : + Command(dot, "Network Session Key", "AT+NSK", "Network session encryption key (16 bytes)"), _serial(serial) +{ + _help = std::string(text()) + ": " + std::string(desc()); + _usage = "(hex:16)"; + _queryable = true; +} + +uint32_t CmdNetworkSessionKey::action(std::vector<std::string> args) +{ + if (args.size() == 1) + { + if (_dot->getVerbose()) + _serial.writef("Network Session Key: "); + + _serial.writef("%s\r\n", mts::Text::bin2hexString(_dot->getNetworkSessionKey(), ".").c_str()); + } + else if (args.size() == 2) + { + int32_t code; + std::vector<uint8_t> NewKey; + + // Read in the key components... + readByteArray(args[1], NewKey, KEY_LENGTH); + + if ((code = _dot->setNetworkSessionKey(NewKey)) == mDot::MDOT_OK) { + _serial.writef("Set Network Session Key: "); + _serial.writef("%s\r\n", mts::Text::bin2hexString(NewKey, ".").c_str()); + } else { + std::string error = mDot::getReturnCodeString(code) + " - " + _dot->getLastError(); + setErrorMessage(error); + return 1; + } + } + + return 0; +} + +bool CmdNetworkSessionKey::verify(std::vector<std::string> args) +{ + if (args.size() == 1) + return true; + + if (args.size() == 2) { + if (!isHexString(args[1], 16)) { + setErrorMessage("Invalid key, expects (hex:16)"); + return false; + } + + return true; + } + + setErrorMessage("Invalid arguments"); + return false; +} diff --git a/CommandTerminal/CmdNetworkSessionKey.h b/CommandTerminal/CmdNetworkSessionKey.h new file mode 100644 index 0000000..4d8cc46 --- /dev/null +++ b/CommandTerminal/CmdNetworkSessionKey.h @@ -0,0 +1,20 @@ +#ifndef __CMDNETWORKSESSIONKEY_H__ +#define __CMDNETWORKSESSIONKEY_H__ + +#include "Command.h" + +class CommandTerminal; + +class CmdNetworkSessionKey : public Command { + +public: + + CmdNetworkSessionKey(mDot* dot, mts::MTSSerial& serial); + virtual uint32_t action(std::vector<std::string> args); + virtual bool verify(std::vector<std::string> args); + +private: + mts::MTSSerial& _serial; +}; + +#endif // __CMDNETWORKSESSIONKEY_H__ diff --git a/CommandTerminal/CmdPublicNetwork.cpp b/CommandTerminal/CmdPublicNetwork.cpp new file mode 100644 index 0000000..74bbeee --- /dev/null +++ b/CommandTerminal/CmdPublicNetwork.cpp @@ -0,0 +1,52 @@ +#include "CmdPublicNetwork.h" + +CmdPublicNetwork::CmdPublicNetwork(mDot* dot, mts::MTSSerial& serial) : + Command(dot, "Public Network", "AT+PN", "Enable/disable public network mode. (0: off, 1: on)"), _serial(serial) +{ + _help = std::string(text()) + ": " + std::string(desc()); + _usage = "(0,1)"; + _queryable = true; +} + +uint32_t CmdPublicNetwork::action(std::vector<std::string> args) +{ + if (args.size() == 1) + { + if (_dot->getVerbose()) + _serial.writef("%s: ", name()); + + _serial.writef("%d\r\n", _dot->getPublicNetwork()); + } + else if (args.size() == 2) + { + int32_t code; + bool enable = (args[1] == "1"); + + if ((code = _dot->setPublicNetwork(enable)) != mDot::MDOT_OK) { + std::string error = mDot::getReturnCodeString(code) + " - " + _dot->getLastError(); + setErrorMessage(error); + return 1; + } + } + + return 0; +} + +bool CmdPublicNetwork::verify(std::vector<std::string> args) +{ + if (args.size() == 1) + return true; + + if (args.size() == 2) + { + if (args[1] != "1" && args[1] != "0") { + setErrorMessage("Invalid parameter, expects (0: off, 1: on)"); + return false; + } + + return true; + } + + setErrorMessage("Invalid arguments"); + return false; +} diff --git a/CommandTerminal/CmdPublicNetwork.h b/CommandTerminal/CmdPublicNetwork.h new file mode 100644 index 0000000..9efec06 --- /dev/null +++ b/CommandTerminal/CmdPublicNetwork.h @@ -0,0 +1,21 @@ +#ifndef __CMDPUBLICNETWORK_H__ +#define __CMDPUBLICNETWORK_H__ + +#include "Command.h" + +class CommandTerminal; + +class CmdPublicNetwork : public Command { + +public: + + CmdPublicNetwork(mDot* dot, mts::MTSSerial& serial); + virtual uint32_t action(std::vector<std::string> args); + virtual bool verify(std::vector<std::string> args); + +private: + + mts::MTSSerial& _serial; +}; + +#endif // __CMDPUBLICNETWORK_H__ diff --git a/CommandTerminal/CmdSaveConfig.cpp b/CommandTerminal/CmdSaveConfig.cpp new file mode 100644 index 0000000..712ba09 --- /dev/null +++ b/CommandTerminal/CmdSaveConfig.cpp @@ -0,0 +1,17 @@ +#include "CmdSaveConfig.h" + +CmdSaveConfig::CmdSaveConfig(mDot* dot) : Command(dot, "Save Configuration", "AT&W", "Save configuration to flash memory") +{ + _help = std::string(text()) + ": " + std::string(desc()); +} + + +uint32_t CmdSaveConfig::action(std::vector<std::string> args) +{ + if (!_dot->saveConfig()) { + setErrorMessage("Failed to save to flash"); + return 1; + } + + return 0; +} diff --git a/CommandTerminal/CmdSaveConfig.h b/CommandTerminal/CmdSaveConfig.h new file mode 100644 index 0000000..dbf9671 --- /dev/null +++ b/CommandTerminal/CmdSaveConfig.h @@ -0,0 +1,17 @@ + +#ifndef __CmdSaveConfig_H__ +#define __CmdSaveConfig_H__ + +#include "Command.h" + +class CmdSaveConfig : public Command { + +public: + + CmdSaveConfig(mDot* dot); + virtual uint32_t action(std::vector<std::string> args); + +private: +}; + +#endif // __CmdSaveConfig_H__ diff --git a/CommandTerminal/CmdTxDataRate.cpp b/CommandTerminal/CmdTxDataRate.cpp new file mode 100644 index 0000000..2d38f42 --- /dev/null +++ b/CommandTerminal/CmdTxDataRate.cpp @@ -0,0 +1,89 @@ +#include "CmdTxDataRate.h" + +CmdTxDataRate::CmdTxDataRate(mDot* dot, mts::MTSSerial& serial) : + Command(dot, "Tx Data Rate", "AT+TXDR", "Set the Tx data rate for all channels"), _serial(serial) +{ + _help = std::string(text()) + ": " + std::string(desc()); + + if (_dot->getFrequencyBand() == mDot::FB_915) + _usage = "(7-10)"; + else + _usage = "(7-12)"; + _queryable = true; +} + +uint32_t CmdTxDataRate::action(std::vector<std::string> args) +{ + if (args.size() == 1) + { + if (_dot->getVerbose()) + _serial.writef("Tx Data Rate: "); + + _serial.writef("%s\r\n", mDot::DataRateStr(_dot->getTxDataRate()).c_str()); + } + else if (args.size() == 2) + { + int32_t code; + uint8_t datarate = 0; + uint8_t i; + + for (i = 0; i < 8; i++) + { + if (mDot::DataRateStr(i).find(args[1].c_str()) != std::string::npos) + { + datarate = i; + break; + } + } + + if ((code = _dot->setTxDataRate(datarate)) != mDot::MDOT_OK) + { + std::string error = mDot::getReturnCodeString(code) + " - " + _dot->getLastError(); + setErrorMessage(error); + return 1; + } + } + + return 0; +} + +bool CmdTxDataRate::verify(std::vector<std::string> args) +{ + if (args.size() == 1) + return true; + + if (args.size() == 2) + { + uint8_t i; + int datarate = -1; + for (i = 0; i < 8; i++) + { + if (mDot::DataRateStr(i).find(args[1].c_str()) != std::string::npos) + { + datarate = i; + break; + } + } + + if (datarate < 0) + { + if (_dot->getFrequencyBand() == mDot::FB_915) + setErrorMessage("Invalid data rate, expects (7-10)"); + else + setErrorMessage("Invalid data rate, expects (7-12)"); + return false; + } + + if (_dot->getFrequencyBand() == mDot::FB_915) { + if (datarate < 2) { + setErrorMessage("Invalid data rate, expects (7-10)"); + return false; + } + } + + return true; + } + + setErrorMessage("Invalid arguments"); + return false; +} diff --git a/CommandTerminal/CmdTxDataRate.h b/CommandTerminal/CmdTxDataRate.h new file mode 100644 index 0000000..e848b9a --- /dev/null +++ b/CommandTerminal/CmdTxDataRate.h @@ -0,0 +1,20 @@ +#ifndef __CMDTXDATARATE_H__ +#define __CMDTXDATARATE_H__ + +#include "Command.h" + +class CommandTerminal; + +class CmdTxDataRate : public Command { + +public: + + CmdTxDataRate(mDot* dot, mts::MTSSerial& serial); + virtual uint32_t action(std::vector<std::string> args); + virtual bool verify(std::vector<std::string> args); + +private: + mts::MTSSerial& _serial; +}; + +#endif // __CMDTXDATARATE_H__ diff --git a/CommandTerminal/CmdTxPower.cpp b/CommandTerminal/CmdTxPower.cpp new file mode 100644 index 0000000..8816b46 --- /dev/null +++ b/CommandTerminal/CmdTxPower.cpp @@ -0,0 +1,62 @@ +#include "CmdTxPower.h" + +CmdTxPower::CmdTxPower(mDot* dot, mts::MTSSerial& serial) : + Command(dot, "Tx Power", "AT+TXP", "Set the Tx power for all channels"), _serial(serial) +{ + _help = std::string(text()) + ": " + std::string(desc()); + _usage = "(2-20)"; + _queryable = true; +} + +uint32_t CmdTxPower::action(std::vector<std::string> args) +{ + if (args.size() == 1) + { + if (_dot->getVerbose()) + _serial.writef("Tx Power: "); + + _serial.writef("%lu\r\n", _dot->getTxPower()); + } + else if (args.size() == 2) + { + int32_t code; + uint32_t power = 0; + sscanf(args[1].c_str(), "%lu", &power); + + if ((code = _dot->setTxPower(power)) != mDot::MDOT_OK) + { + std::string error = mDot::getReturnCodeString(code) + " - " + _dot->getLastError(); + setErrorMessage(error); + return 1; + } + } + + return 0; +} + +bool CmdTxPower::verify(std::vector<std::string> args) +{ + if (args.size() == 1) + return true; + + if (args.size() == 2) + { + uint32_t power = 0; + if (sscanf(args[1].c_str(), "%lu", &power) != 1) { + setErrorMessage("Invalid argument"); + return false; + } + + if (power < 2 || power > 20) + { + setErrorMessage("Invalid power, expects (2-20)"); + return false; + } + + return true; + } + + setErrorMessage("Invalid arguments"); + return false; +} + diff --git a/CommandTerminal/CmdTxPower.h b/CommandTerminal/CmdTxPower.h new file mode 100644 index 0000000..4b12b08 --- /dev/null +++ b/CommandTerminal/CmdTxPower.h @@ -0,0 +1,21 @@ +#ifndef __CMDTXPOWER_H__ +#define __CMDTXPOWER_H__ + +#include "Command.h" + +class CommandTerminal; + +class CmdTxPower: public Command +{ + +public: + + CmdTxPower(mDot* dot, mts::MTSSerial& serial); + virtual uint32_t action(std::vector<std::string> args); + virtual bool verify(std::vector<std::string> args); + +private: + mts::MTSSerial& _serial; +}; + +#endif // __CMDTXPOWER_H__ diff --git a/CommandTerminal/Command.cpp b/CommandTerminal/Command.cpp new file mode 100644 index 0000000..5282f45 --- /dev/null +++ b/CommandTerminal/Command.cpp @@ -0,0 +1,128 @@ +#include "Command.h" +#include <algorithm> + +const char Command::newline[] = "\r\n"; + +Command::Command(mDot* dot) : _dot(dot) +{ + _usage = "NONE"; + _queryable = false; +} + +Command::Command(mDot* dot, const char* name, const char* text, const char* desc) : + _dot(dot), _name(name), _text(text), _desc(desc) +{ + _usage = "NONE"; + _queryable = false; +} + +std::string &Command::errorMessage() +{ + return _errorMessage; +} + +void Command::setErrorMessage(const char* message) +{ + _errorMessage.assign(message); +} + +void Command::setErrorMessage(const std::string& message) +{ + _errorMessage.assign(message); +} + +const std::string Command::usage() const +{ + std::string usage(_text); + usage.append(": "); + usage.append(_usage); + return usage; +} + +const bool Command::queryable() +{ + return _queryable; +} + +void Command::readByteArray(const std::string& input, std::vector<uint8_t>& out, size_t len) +{ + // if input length is greater than expected byte output + // there must be a delimiter included + if (input.length() > len * 2) + { + std::vector < std::string > bytes; + if (input.find(" ") != std::string::npos) + bytes = mts::Text::split(input, " "); + else if (input.find(":") != std::string::npos) + bytes = mts::Text::split(input, ":"); + else if (input.find("-") != std::string::npos) + bytes = mts::Text::split(input, "-"); + else if (input.find(".") != std::string::npos) + bytes = mts::Text::split(input, "."); + + if (bytes.size() != len) { + return; + } + + uint8_t temp; + // Read in the key components... + for (size_t i = 0; i < len; i++) + { + sscanf(bytes[i].c_str(), "%02x", &temp); + out.push_back(temp); + } + } + else + { + // no delims + uint8_t temp; + + // Read in the key components... + for (size_t i = 0; i < len; i++) + { + if (i * 2 < input.size()) + { + sscanf(input.substr(i * 2).c_str(), "%02x", &temp); + out.push_back(temp); + } + } + } +} + +bool Command::isHexString(const std::string& str, size_t bytes) { + size_t numDelims = bytes - 1; + size_t minSize = bytes * 2; + size_t maxSize = minSize + numDelims; + + if (str.size() == minSize) { + return str.find_first_not_of("0123456789abcdefABCDEF") == std::string::npos; + } + else if (str.size() == maxSize) { + if (str.find_first_of(":-.") == std::string::npos) { + // no delim found + return false; + } + if (str.find(":") != std::string::npos && std::count(str.begin(), str.end(), ':') != numDelims) { + return false; + } + if (str.find(".") != std::string::npos && std::count(str.begin(), str.end(), '.') != numDelims) { + return false; + } + if (str.find("-") != std::string::npos && std::count(str.begin(), str.end(), '-') != numDelims) { + return false; + } + + return str.find_first_not_of("0123456789abcdefABCDEF:-.") == std::string::npos; + } + + return false; +} + +bool Command::verify(std::vector<std::string> args) { + if (args.size() == 1) + return true; + + setErrorMessage("Invalid arguments"); + return false; +} + diff --git a/CommandTerminal/Command.h b/CommandTerminal/Command.h new file mode 100644 index 0000000..bf46158 --- /dev/null +++ b/CommandTerminal/Command.h @@ -0,0 +1,98 @@ +/** + ****************************************************************************** + * File Name : Command.h + * Date : 18/04/2014 10:57:12 + * Description : This file provides code for command line prompt + ****************************************************************************** + * + * COPYRIGHT(c) 2014 MultiTech Systems, Inc. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * 3. Neither the name of STMicroelectronics nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ****************************************************************************** + */ + +#include "mbed.h" +#include "mDot.h" +#include "MTSSerial.h" +#include "MTSText.h" +#include <cstdlib> +#include <string> +#include <vector> +#include "limits.h" +#include "debug.h" + +/* Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __command_H +#define __command_H + +#define KEY_LENGTH 16 +#define EUI_LENGTH 8 +#define PASSPHRASE_LENGTH 128 + +class Command { + + public: + + Command(mDot* dot); + Command(mDot* dot, const char* name, const char* text, const char* desc); + virtual ~Command() {}; + + const char* name() const { return _name; }; + const char* text() const { return _text; }; + const char* desc() const { return _desc; }; + const char* help() const { return _help.c_str(); }; + + virtual uint32_t action(std::vector<std::string> args) = 0; + virtual bool verify(std::vector<std::string> args); + const std::string usage() const; + std::string& errorMessage(); + const bool queryable(); + + static const char newline[]; + static void readByteArray(const std::string& input, std::vector<uint8_t>& out, size_t len); + + static bool isHexString(const std::string& str, size_t bytes); + static bool isBaudRate(uint32_t baud); + + protected: + + void setErrorMessage(const char* message); + void setErrorMessage(const std::string& message); + std::string _help; + std::string _usage; + bool _queryable; + mDot* _dot; + + private: + + const char* _name; + const char* _text; + const char* _desc; + std::string _errorMessage; + +}; + +#endif /*__ command_H */ + +/************************ (C) COPYRIGHT MultiTech Systems, Inc *****END OF FILE****/ diff --git a/CommandTerminal/CommandTerminal.cpp b/CommandTerminal/CommandTerminal.cpp new file mode 100644 index 0000000..65509bb --- /dev/null +++ b/CommandTerminal/CommandTerminal.cpp @@ -0,0 +1,631 @@ +#include "ctype.h" +#include "CommandTerminal.h" +#include "Command.h" +#include "MTSLog.h" +#include <cstdarg> +#include <deque> + +const char CommandTerminal::banner[] = "\r\n\nMultiTech Systems LoRa XBee Module\r\n\n"; +const char CommandTerminal::helpline[] = "Enter '?' for help\r\n"; + +const char CommandTerminal::newline[] = "\r\n"; + +// Command error text... +const char CommandTerminal::command_error[] = "Command not found!\r\n"; + +// Response texts... +const char CommandTerminal::help[] = "\r\nHelp\r\n"; +const char CommandTerminal::cmd_error[] = "Invalid command\r\n"; +const char CommandTerminal::done[] = "\r\nOK\r\n"; +const char CommandTerminal::error[] = "\r\nERROR\r\n"; + +// Escape sequence... +const char CommandTerminal::escape_sequence[] = "+++"; + +mts::MTSSerial* CommandTerminal::_serialp = NULL; + +void CommandTerminal::addCommand(Command* cmd) { + _commands.push_back(cmd); +} + +CommandTerminal::CommandTerminal(mts::MTSSerial& serial, mDot* dot) +: + _serial(serial), + _dot(dot), + _mode(mDot::COMMAND_MODE), + _idle_thread(idle, NULL, osPriorityLow), + _sleep_standby(true), + _xbee_on_sleep(XBEE_ON_SLEEP), + _serial_up(false) { + + _serialp = &serial; + + addCommand(new CmdAttention(_dot)); + addCommand(new CmdIdentification(_dot, serial)); + addCommand(new CmdFactoryDefault(_dot)); + addCommand(new CmdSaveConfig(_dot)); + addCommand(new CmdDisplayConfig(_dot, serial)); + + addCommand(new CmdFrequencySubBand(_dot, serial)); + addCommand(new CmdPublicNetwork(_dot, serial)); + addCommand(new CmdDeviceId(_dot, serial)); + + addCommand(new CmdNetworkAddress(_dot, serial)); + addCommand(new CmdNetworkSessionKey(_dot, serial)); + addCommand(new CmdDataSessionKey(_dot, serial)); + addCommand(new CmdNetworkKey(_dot, serial)); + addCommand(new CmdNetworkId(_dot, serial)); + + addCommand(new CmdNetworkJoinMode(_dot, serial)); + addCommand(new CmdTxDataRate(_dot, serial)); + addCommand(new CmdTxPower(_dot, serial)); +} + +void CommandTerminal::printHelp() { + const char* name = NULL; + const char* text = NULL; + const char* desc = NULL; + const char* tab = "\t"; + + std::string header("Command"); + header.append(tab); + header.append(tab); + header.append("Name"); + header.append(tab); + header.append(tab); + header.append(tab); + header.append("Description"); + + write(newline); + write(header.c_str()); + write(newline); + write(newline); + for (std::vector<Command*>::iterator it = _commands.begin(); it != _commands.end(); ++it) { + name = (*it)->name(); + text = (*it)->text(); + desc = (*it)->desc(); + write(text); + if (strlen(text) < 8) + write(tab); + write(tab); + write(name); + if (strlen(name) < 8) + write(tab); + if (strlen(name) < 16) + write(tab); + write(tab); + write(desc); + write(newline); + } + + write(newline); +} + +bool CommandTerminal::writeable() { + return _serial.writeable(); +} + +bool CommandTerminal::readable() { + return _serial.readable(); +} + +char CommandTerminal::read() { + char ch; + _serial.read(&ch, 1); + return ch; +} + +void CommandTerminal::write(const char* message) { + while (!writeable()) + ; + _serial.write(message, strlen(message)); +} + +void CommandTerminal::writef(const char* format, ...) { + char buff[256]; + + va_list ap; + va_start(ap, format); + int size = vsnprintf(buff, 256, format, ap); + while (!writeable()) + ; + _serial.write(buff, size); + va_end(ap); +} + +void CommandTerminal::serial_loop() { + Timer serial_read_timer; + std::vector<uint8_t> serial_buffer; + std::string escape_buffer; + Timer escape_timer; + int escape_delay = 100; + uint8_t max_send_size; + + _serial_up = true; + _xbee_on_sleep = GPIO_PIN_SET; + + if (_dot->getFrequencyBand() == mDot::FB_915) + max_send_size = mDot::MaxLengths_915[_dot->getTxDataRate()]; + else + max_send_size = mDot::MaxLengths_868[_dot->getTxDataRate()]; + + logDebug("Awake\r\n"); + wakeup(_sleep_standby); + + char ch; + + if (readable()) { + ch = read(); + serial_buffer.push_back(ch); + + if (escape_timer.read_ms() > escape_delay && ch == '+') { + escape_buffer += ch; + escape_timer.reset(); + } else { + _serial_up = true; + escape_buffer.clear(); + } + + if (escape_buffer.length() == 3 && escape_buffer.find(escape_sequence) == 0) { + _mode = mDot::COMMAND_MODE; + logDebug("Exit serial mode\r\n"); + escape_timer.stop(); + escape_buffer.clear(); + write(done); + return; + } + } + + if (_serial_up) { + serial_read_timer.start(); + uint32_t timeout = _dot->getWakeDelay(); + + // wait for timeout or start of serial data + while (!readable() && serial_read_timer.read_ms() < timeout) { + osDelay(10); + } + + serial_read_timer.reset(); + timeout = _dot->getWakeTimeout(); + while (_serial_up && serial_read_timer.read_ms() < timeout) { + while (readable() && serial_buffer.size() < max_send_size) { + serial_buffer.push_back(read()); + serial_read_timer.reset(); + } + } + serial_read_timer.stop(), serial_read_timer.reset(); + + if (!serial_buffer.empty()) { + _serial_up = false; + _xbee_on_sleep = GPIO_PIN_RESET; + if (!_dot->getIsTransmitting()) { + std::vector<uint8_t> recv_buffer; + logDebug("Received serial data, sending out radio.\r\n"); + + if (_dot->send(serial_buffer) != mDot::MDOT_OK) + logDebug("Send failed.\r\n"); + + if (_dot->recv(recv_buffer)) + _serial.writef("%s\r\n", formatPacketData(recv_buffer, _dot->getRxOutput()).c_str()); + } else { + logDebug("Radio is busy, cannot send.\r\n"); + } + + serial_buffer.clear(); + } else { + logDebug("No data received from serial to send.\r\n"); + } + _serial_up = false; + } + sleep(_sleep_standby); +} + +bool CommandTerminal::autoJoinCheck() { + + std::string escape_buffer; + char ch; + int sleep = 1000; + int escape_timeout = 1000; + Timer tmr; + Timer escape_tmr; + int cnt = 0; + + while (!_dot->getNetworkJoinStatus()) { + wakeup(_sleep_standby); + write("\r\nJoining network... "); + + // wait one second for possible escape + tmr.reset(); + tmr.start(); + escape_tmr.reset(); + escape_tmr.start(); + while (tmr.read_ms() < 1000) { + if (_serial.readable()) { + _serial.read(&ch, 1); + escape_buffer += ch; + } + + if (escape_buffer.find(escape_sequence) != std::string::npos) { + _mode = mDot::COMMAND_MODE; + write("Join Canceled\r\n"); + write(done); + return true; + } + + if (escape_tmr.read_ms() > escape_timeout) + escape_buffer.clear(); + } + + if (_dot->joinNetworkOnce() == mDot::MDOT_OK) { + write("Network Joined\r\n"); + write(done); + return false; + } + + write("Network Join failed\r\n"); + write(error); + + if (cnt++ > _dot->getJoinRetries()) { + cnt = 0; + + if (_dot->getFrequencyBand() == mDot::FB_915) { + uint8_t band = ((_dot->getFrequencySubBand()) % 8) + 1; + logDebug("Join retries exhausted, switching to sub band %u\r\n", band); + _dot->setFrequencySubBand(band); + } + + if (sleep < 60 * 60 * 1000) + sleep *= 2; + } + + tmr.reset(); + tmr.start(); + escape_tmr.reset(); + escape_tmr.start(); + while (tmr.read_ms() < sleep) { + if (_serial.readable()) { + _serial.read(&ch, 1); + escape_buffer += ch; + } + + if (escape_buffer.find(escape_sequence) != std::string::npos) { + _mode = mDot::COMMAND_MODE; + return true; + } + + if (escape_tmr.read_ms() > escape_timeout) + escape_buffer.clear(); + } + + } + + return false; +} + +void CommandTerminal::start() { + + wakeup(_sleep_standby); + + char ch; + bool running = true; + bool echo = _dot->getEcho(); + std::string command; + std::deque<std::string> history; + int history_index = -1; + std::vector<std::string> args; + + if (_dot->getStartUpMode() == mDot::SERIAL_MODE) { + command = "AT+SD\n"; + + std::string escape_buffer; + char ch; + + int escape_timeout = 1000; + Timer tmr; + Timer escape_tmr; + + // wait one second for possible escape + tmr.reset(); + tmr.start(); + escape_tmr.reset(); + escape_tmr.start(); + while (tmr.read_ms() < escape_timeout) { + if (_serial.readable()) { + _serial.read(&ch, 1); + escape_buffer += ch; + } + + if (escape_buffer.find(escape_sequence) != std::string::npos) { + _mode = mDot::COMMAND_MODE; + command.clear(); + break; + } + + if (escape_tmr.read_ms() > escape_timeout) + escape_buffer.clear(); + + osDelay(1); + } + + } + + bool join_canceled = false; + + //Run terminal session + while (running) { + if (!join_canceled && _dot->getJoinMode() == mDot::AUTO_OTA) { + join_canceled = autoJoinCheck(); + if (join_canceled) + command.clear(); + } + + if (_dot->getJoinMode() != mDot::AUTO_OTA || (!join_canceled && _dot->getJoinMode() == mDot::AUTO_OTA)) { + switch (_mode) { + case mDot::SERIAL_MODE: + // signal wakeup, read serial and output to radio + serial_loop(); + continue; + break; + default: + break; + } + } + + ch = '\0'; + + // read characters + if (readable()) { + ch = read(); + + if (ch == '\b' || ch == 0x7f) { + if (!command.empty()) { + writef("\b \b"); + command.erase(command.size() - 1); + } + continue; + } else if (ch == 0x1b || ch == 0x09) { + osDelay(20); + // catch escape sequence, or tab + char ch1, ch2; + + if (readable()) { + ch1 = read(); + if (readable()) + ch2 = read(); + + if (ch1 == 0x5b && ch2 == 0x41) { + // up key + for (int i = 0; i < command.size()+1; i++) { + writef("\b \b"); + } + if (history.size() > 0) { + if (++history_index >= history.size() - 1) + history_index = history.size() - 1; + + command = history[history_index]; + writef("%s", history[history_index].c_str()); + } else { + command.clear(); + } + } else if (ch1 == 0x5b && ch2 == 0x42) { + + // down key + for (int i = 0; i < command.size()+1; i++) { + writef("\b \b"); + } + + if (--history_index < 0) { + history_index = -1; + command.clear(); + } else { + command = history[history_index]; + writef("%s", history[history_index].c_str()); + } + } + } + while (readable()) read(); + continue; + } else { + command += ch; + } + + // echo chars if enabled + if (echo && !(ch == '\r' || ch == '\n')) + writef("%c", ch); + } + + // look for end of command line + if (command.find("\n") != std::string::npos || command.find("\r") != std::string::npos) { + // remove new line or cr character + command.erase(command.size() - 1); + write("\r"); // match standard modem output + write(newline); + } else { + continue; + } + + // trim whitespace from command + mts::Text::trim(command, "\r\n\t "); + + if (command.size() < 1) { + command.clear(); + continue; + } + + // parse command and args + args.clear(); + + // find first '=' character + size_t delim_index = command.find("="); + if (delim_index != std::string::npos) { + args.push_back(command.substr(0, delim_index)); + } else { + // find first ' ' character + delim_index = command.find(" "); + if (delim_index != std::string::npos) { + args.push_back(command.substr(0, delim_index)); + } else { + args.push_back(command); + } + } + + if (delim_index != std::string::npos) { + std::vector<std::string> params = mts::Text::split(command.substr(delim_index + 1), ","); + args.insert(args.end(), params.begin(), params.end()); + } + + args[0] = mts::Text::toUpper(args[0]); + + // print help + if ((args[0].find("?") == 0 || args[0].find("HELP") == 0) && args.size() == 1) { + printHelp(); + command.clear(); + } else if (args[0].find("ATE0") == 0 && args[0].length() == 4) { + _dot->setEcho(false); + write(done); + echo = _dot->getEcho(); + } else if (args[0].find("ATE1") == 0 && args[0].length() == 4) { + _dot->setEcho(true); + write(done); + echo = _dot->getEcho(); + } else if (args[0].find("ATV0") == 0 && args[0].length() == 4) { + _dot->setVerbose(false); + write(done); + } else if (args[0].find("ATV1") == 0 && args[0].length() == 4) { + _dot->setVerbose(true); + write(done); + } else if (args[0] == "AT+SD") { + logDebug("Enter Serial Mode\r\n"); + _mode = mDot::SERIAL_MODE; + } else if (args[0] == "AT+SLEEP") { + if (args.size() > 1 && (args[1] != "?")) { + write("Invalid argument\r\n"); + write(error); + } else { + if (args.size() > 1 && args[1] == "?") { + write("AT+SLEEP: NONE\r\n"); + write(done); + } else { + _sleep_standby = !(args.size() > 1 && args[1] == "1"); + this->sleep(_sleep_standby); + wait(0.1); + write(done); + } + } + } else { + bool found = false; + bool query = false; + + std::string lookfor = args[0]; + + // per command help + if ((args[0].find("?") == 0 || args[0].find("HELP") == 0)) + lookfor = mts::Text::toUpper(args[1]); + + // trim off any trailing '?' and mark as a query command + if (args[0].rfind("?") == args[0].length() - 1) { + query = true; + lookfor = args[0].substr(0, args[0].length() - 1); + } + + // search for command + for (std::vector<Command*>::iterator it = _commands.begin(); it != _commands.end() && !found; ++it) { + Command* cmd = *it; + + // match CMD or CMD? syntax if command is queryable + if (lookfor == cmd->text() && (!query || (query && cmd->queryable()))) { + found = true; + if (args[0] == "HELP") { + writef("%s%s", cmd->help(), newline); + write(done); + } + + else if (args.size() > 1 && args[1] == "?") { + writef("%s%s", cmd->usage().c_str(), newline); + write(done); + } else if (!cmd->verify(args)) { + writef("%s%s", cmd->errorMessage().c_str(), newline); + writef("%s", error); + } else { + if (cmd->action(args) == 0) { + writef("%s", done); + } else { + writef("%s%s", cmd->errorMessage().c_str(), newline); + writef("%s", error); + } + } + } + } + + if (!found) { + writef("%s", command_error); + writef("%s", error); + } + } + + if (history.size() == 0 || history.front() != command) + history.push_front(command); + history_index = -1; + command.clear(); + + while (history.size() > 10) + history.pop_back(); + + } +} + +std::string CommandTerminal::formatPacketData(const std::vector<uint8_t>& data, const uint8_t& format) { + if (format == mDot::HEXADECIMAL) + return mts::Text::bin2hexString(data); + else + return std::string(data.begin(), data.end()); +} + +void CommandTerminal::sleep(bool standby) { + _serial_up = false; + _xbee_on_sleep = GPIO_PIN_RESET; + + _serial.rxClear(); + _serial.txClear(); + + _dot->sleep(_dot->getWakeInterval(), _dot->getWakeMode(), standby); +} + +bool CommandTerminal::waitForEscape(int timeout, mDot* dot, WaitType wait) { + Timer timer; + Timer escape_timer; + std::string escape_buffer; + int escape_timeout = 1000; + + timer.start(); + while (timer.read_ms() < timeout) { + + if (dot != NULL) { + if (wait == WAIT_SEND && (!dot->getIsTransmitting())) { + return false; + } + } + + if (_serialp != NULL && _serialp->readable()) { + if (escape_buffer == "") + escape_timer.start(); + char ch; + _serialp->read(&ch, 1); + escape_buffer += ch; + if (escape_buffer == CommandTerminal::escape_sequence) + return true; + } + if (escape_timer.read_ms() > escape_timeout) { + escape_buffer = ""; + escape_timer.stop(), escape_timer.reset(); + } + + osDelay(10); + } + + return false; +} + +void CommandTerminal::wakeup(bool standby) { + +} diff --git a/CommandTerminal/CommandTerminal.h b/CommandTerminal/CommandTerminal.h new file mode 100644 index 0000000..e64ec41 --- /dev/null +++ b/CommandTerminal/CommandTerminal.h @@ -0,0 +1,118 @@ +/** + ****************************************************************************** + * File Name : command.h + * Date : 18/04/2014 10:57:12 + * Description : This file provides code for command line prompt + ****************************************************************************** + * + * COPYRIGHT(c) 2014 MultiTech Systems, Inc. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * 3. Neither the name of STMicroelectronics nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ****************************************************************************** + */ + +#include "mbed.h" +#include "MTSSerial.h" +#include "Commands.h" +#include "mDot.h" + +/* Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __command_terminal_H__ +#define __command_terminal_H__ + +class CommandTerminal { + +public: + + enum WaitType { + WAIT_JOIN, + WAIT_RECV, + WAIT_LINK, + WAIT_SEND, + WAIT_NA + }; + + CommandTerminal(mts::MTSSerial& serial, mDot* dot); + + // Command prompt text... + static const char banner[]; + static const char helpline[]; + static const char prompt[]; + + // Command error text... + static const char command_error[]; + + // Response texts... + static const char help[]; + static const char cmd_error[]; + static const char newline[]; + static const char done[]; + static const char error[]; + + // Escape sequence + static const char escape_sequence[]; + + static std::string formatPacketData(const std::vector<uint8_t>& data, const uint8_t& format); + static bool waitForEscape(int timeout, mDot* dot=NULL, WaitType wait=WAIT_NA); + + void start(); + +private: + + static void idle(void const* args) { + while (1) + __WFI(); + } + + mts::MTSSerial& _serial; + static mts::MTSSerial* _serialp; + + mDot* _dot; + mDot::Mode _mode; + std::vector<Command*> _commands; + Thread _idle_thread; + bool _sleep_standby; + DigitalOut _xbee_on_sleep; + bool _serial_up; + + void addCommand(Command* cmd); + + void serial_loop(); + bool autoJoinCheck(); + + void printHelp(); + + bool readable(); + bool writeable(); + char read(); + void write(const char* message); + void writef(const char* format, ... ); + + void sleep(bool standby); + void wakeup(bool standby); + +}; + +#endif // __command_terminal_H__ + diff --git a/CommandTerminal/Commands.h b/CommandTerminal/Commands.h new file mode 100644 index 0000000..5b699f4 --- /dev/null +++ b/CommandTerminal/Commands.h @@ -0,0 +1,19 @@ +#include "Command.h" + +#include "CmdAttention.h" +#include "CmdIdentification.h" + +#include "CmdFactoryDefault.h" +#include "CmdSaveConfig.h" +#include "CmdDisplayConfig.h" +#include "CmdDeviceId.h" +#include "CmdPublicNetwork.h" +#include "CmdNetworkAddress.h" +#include "CmdNetworkSessionKey.h" +#include "CmdDataSessionKey.h" +#include "CmdNetworkKey.h" +#include "CmdNetworkId.h" +#include "CmdNetworkJoinMode.h" +#include "CmdTxDataRate.h" +#include "CmdTxPower.h" +#include "CmdFrequencySubBand.h" diff --git a/CommandTerminal/Test/TestCommandTerminal.h b/CommandTerminal/Test/TestCommandTerminal.h new file mode 100644 index 0000000..0d5e801 --- /dev/null +++ b/CommandTerminal/Test/TestCommandTerminal.h @@ -0,0 +1,82 @@ +#ifndef TESTCOMMANDTERMINAL_H +#define TESTCOMMANDTERMINAL_H + +#include <string> +#include <vector> + +#include "Commands.h" + +class MockSerial +{ + +public: + std::string read_buff; + std::string write_buff; + + int read(char* buff, int len) + { + + return 0; + } + + int write(char* buff) + { + write_buff.append(buff); + return 0; + } + + int writef(char* buff) + { + printf("MockSerial writef\r\n"); + write_buff.append(buff); + return 0; + } +}; + +class TestCommandTerminal: public TestCollection +{ +public: + TestCommandTerminal(); + ~TestCommandTerminal(); + + virtual void run(); + +}; + +TestCommandTerminal::TestCommandTerminal() : + TestCollection("CommandTerminal") +{ +} + +TestCommandTerminal::~TestCommandTerminal() +{ +} + +void TestCommandTerminal::run() +{ + MockSerial test_serial; + + Test::start("Test AT"); + CmdAttention at_cmd; + Test::assertTrue(std::string("AT").compare(at_cmd.text()) == 0); + std::vector < std::string > args; + args.push_back("AT"); + args.push_back("IGNORED"); + Test::assertTrue(at_cmd.verify(args)); + Test::assertTrue(at_cmd.action(args) == 0); + Test::end(); + +// Test::start("Test ATI"); +// printf("testing ati\r\n"); +// CmdIdentification ati_cmd((mts::MTSSerial&)test_serial); +// printf("cmd created\r\n"); +// Test::assertTrue(at_cmd.verify(args)); +// printf("verified\r\n"); +// Test::assertTrue(at_cmd.action(args) == 0); +// printf("actionied\r\n"); +// Test::assertTrue(test_serial.write_buff.find("MultiTech") == 0); +// Test::end(); + +} + +#endif /* TESTCOMMANDTERMINAL_H */ |