MultiTech
/
mDot_AT_firmware_CUSTOM
Important changes to repositories hosted on mbed.com
Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.
To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.
It is also possible to export all your personal repositories from the account settings page.
Dependencies: libmDot-Custom MTS-Serial
Fork of
mDot_AT_firmware_CUSTOM
by 
Jason Reiss
To change channel plans replace AS923 with AU915, EU868, KR920 or US915 on line 15
#define CHANNEL_PLAN CP_AS923
Diff: CommandTerminal/CommandTerminal.cpp
- Revision:
- 12:98445fa50cd3
- Parent:
- 11:05e0f30c03a6
- Child:
- 15:36db31c18231
--- a/CommandTerminal/CommandTerminal.cpp Mon Aug 22 19:34:26 2016 +0000
+++ b/CommandTerminal/CommandTerminal.cpp Mon Aug 29 14:05:16 2016 +0000
@@ -1,807 +1,1083 @@
-#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::connect[] = "\r\nCONNECT\r\n";
-const char CommandTerminal::no_carrier[] = "\r\nNO CARRIER\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::ATSerial* CommandTerminal::_serialp = NULL;
-
-static bool serial_data_mode = false;
-static bool peer_to_peer = false;
-
-void CommandTerminal::addCommand(Command* cmd) {
- _commands.push_back(cmd);
-}
-
-CommandTerminal::CommandTerminal(mts::ATSerial& serial, mDot* dot)
-:
- _serial(serial),
- _dot(dot),
- _events(new RadioEvent(serial)),
- _mode(mDot::COMMAND_MODE),
- _idle_thread(idle, NULL, osPriorityLow),
- _sleep_standby(true),
- _xbee_on_sleep(XBEE_ON_SLEEP) {
-
- _dot->setEvents(_events);
- _dot->setWakeupCallback(this, &CommandTerminal::wakeup);
- _serialp = &serial;
-
- addCommand(new CmdAttention(_dot));
- addCommand(new CmdIdentification(_dot, serial));
- addCommand(new CmdResetCpu(_dot, serial));
- addCommand(new CmdDummy(_dot, "Enable/Disable Echo", "ATE", "ATE0: disable, ATE1: enable"));
- addCommand(new CmdDummy(_dot, "Enable/Disable Verbose", "ATV", "ATV0: disable, ATV1: enable"));
- addCommand(new CmdDummy(_dot, "Hardware Flow Control", "AT&K", "AT&K0: disable, AT&K3: enable"));
-
- addCommand(new CmdFactoryDefault(_dot));
- addCommand(new CmdSaveConfig(_dot));
- addCommand(new CmdDisplayConfig(_dot, serial));
- addCommand(new CmdDisplayStats(_dot, serial));
- addCommand(new CmdResetStats(_dot, serial));
- addCommand(new CmdSerialBaudRate(_dot, serial));
- addCommand(new CmdDebugBaudRate(_dot, serial));
- addCommand(new CmdStartUpMode(_dot, serial));
-
- addCommand(new CmdFrequencyBand(_dot, serial));
- addCommand(new CmdFrequencySubBand(_dot, serial));
- addCommand(new CmdPublicNetwork(_dot, serial));
- addCommand(new CmdDeviceId(_dot, serial));
- addCommand(new CmdDeviceClass(_dot, serial));
-
- addCommand(new CmdAppPort(_dot, serial));
- addCommand(new CmdNetworkAddress(_dot, serial));
- addCommand(new CmdNetworkSessionKey(_dot, serial));
- addCommand(new CmdDataSessionKey(_dot, serial));
- addCommand(new CmdUplinkCounter(_dot, serial));
- addCommand(new CmdDownlinkCounter(_dot, serial));
- addCommand(new CmdSaveSession(_dot, serial));
- addCommand(new CmdRestoreSession(_dot, serial));
- addCommand(new CmdNetworkKey(_dot, serial));
- addCommand(new CmdNetworkId(_dot, serial));
-
- addCommand(new CmdJoinDelay(_dot, serial));
- addCommand(new CmdJoinRequest(_dot, serial));
- addCommand(new CmdJoinRetries(_dot, serial));
- addCommand(new CmdJoinByteOrder(_dot, serial));
- addCommand(new CmdNetworkJoinMode(_dot, serial));
- addCommand(new CmdPreserveSession(_dot, serial));
- addCommand(new CmdNetworkJoinStatus(_dot, serial));
- addCommand(new CmdNetworkLinkCheck(_dot, serial));
- addCommand(new CmdLinkCheckCount(_dot, serial));
- addCommand(new CmdLinkCheckThreshold(_dot, serial));
- addCommand(new CmdEncryption(_dot, serial));
-
- addCommand(new CmdRssi(_dot, serial));
- addCommand(new CmdSnr(_dot, serial));
- addCommand(new CmdDataPending(_dot, serial));
-
- addCommand(new CmdSessionDataRate(_dot, serial));
-
- addCommand(new CmdTxDataRate(_dot, serial));
- addCommand(new CmdTxPower(_dot, serial));
- addCommand(new CmdAntennaGain(_dot, serial));
- addCommand(new CmdTxFrequency(_dot, serial));
- addCommand(new CmdTxInverted(_dot, serial));
- addCommand(new CmdTxWait(_dot, serial));
- addCommand(new CmdTxChannel(_dot, serial));
- addCommand(new CmdTxNextMs(_dot, serial));
- addCommand(new CmdTimeOnAir(_dot, serial));
-
- addCommand(new CmdRxDelay(_dot, serial));
- addCommand(new CmdRxOutput(_dot, serial));
- addCommand(new CmdRxInverted(_dot, serial));
-
- addCommand(new CmdErrorCorrection(_dot, serial));
- addCommand(new CmdCRC(_dot, serial));
- addCommand(new CmdAdaptiveDataRate(_dot, serial));
-
- addCommand(new CmdACKAttempts(_dot, serial));
- addCommand(new CmdRepeat(_dot, serial));
-
- addCommand(new CmdSendString(_dot, serial));
- addCommand(new CmdSendBinary(_dot, serial));
- addCommand(new CmdReceiveOnce(_dot, serial));
-
- addCommand(new CmdDummy(_dot, "Serial Data Mode", "AT+SD", "Enter serial data mode, exit with '+++'"));
- addCommand(new CmdDummy(_dot, "Sleep Mode", "AT+SLEEP", "Enter sleep mode (0:deepsleep,1:sleep)"));
- addCommand(new CmdSerialClearOnError(_dot, serial));
- addCommand(new CmdWakeMode(_dot, serial));
- addCommand(new CmdWakeInterval(_dot, serial));
- addCommand(new CmdWakePin(_dot, serial));
- addCommand(new CmdWakeDelay(_dot, serial));
- addCommand(new CmdWakeTimeout(_dot, serial));
- addCommand(new CmdPing(_dot, serial));
- addCommand(new CmdLogLevel(_dot, serial));
-
- addCommand(new CmdDummy(_dot, "***** Test Commands *****", "", ""));
- addCommand(new CmdRxDataRate(_dot, serial));
- addCommand(new CmdRxFrequency(_dot, serial));
- addCommand(new CmdReceiveContinuous(_dot, serial));
- addCommand(new CmdSendStringOnInterval(_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::serialLoop() {
- Timer serial_read_timer;
- std::vector<uint8_t> serial_buffer;
- std::vector<uint8_t> data;
- int timeout = 0;
-
- serial_read_timer.start();
-
- if (_dot->getStartUpMode() == mDot::SERIAL_MODE) {
- _xbee_on_sleep = GPIO_PIN_SET;
-
- timeout = _dot->getWakeDelay();
-
- // wait for timeout or start of serial data
- while (!readable() && serial_read_timer.read_ms() < timeout && !_serial.escaped()) {
- osDelay(2);
- }
- }
-
- if (readable() && !_serial.escaped()) {
-
- serial_read_timer.reset();
- timeout = _dot->getWakeTimeout();
-
- while (serial_read_timer.read_ms() < timeout && serial_buffer.size() <= _dot->getMaxPacketLength()) {
- while (readable() && serial_buffer.size() < _dot->getMaxPacketLength()) {
- serial_buffer.push_back(read());
- serial_read_timer.reset();
-
- if (_serial.escaped())
- break;
- }
- }
-
- serial_read_timer.stop(), serial_read_timer.reset();
-
- if (!serial_buffer.empty()) {
- if (_dot->getStartUpMode() == mDot::SERIAL_MODE)
- _xbee_on_sleep = GPIO_PIN_RESET;
-
- // wait for any duty cycle limit to expire
- while (_dot->getNextTxMs() > 0 && !_serial.escaped()) {
- osDelay(10);
- }
-
- if (!_dot->getIsTransmitting()) {
- logDebug("Received serial data, sending out radio.");
-
- if (_dot->send(serial_buffer, false) != mDot::MDOT_OK) {
- logDebug("Send failed.");
- // If the data should be tossed after send failure, clear buffer
- if (_dot->getSerialClearOnError()) {
- serial_buffer.clear();
- }
- } else {
-
- // wait for send to finish
- while (_dot->getIsTransmitting() && !_serial.escaped())
- osDelay(10);
-
- // call recv to wait for any packet before sending again
- if (!_serial.escaped())
- _dot->recv(data);
-
- // Clear the serial buffer if send is success
- serial_buffer.clear();
- }
- } else {
- logDebug("Radio is busy, cannot send.\r\n");
- osDelay(10);
- }
-
- } else {
- logDebug("No data received from serial to send.\r\n");
- }
- }
-
- if (!_serial.readable() && _dot->getStartUpMode() == mDot::SERIAL_MODE && !_serial.escaped()) {
- _xbee_on_sleep = GPIO_PIN_RESET;
- sleep(_sleep_standby);
- }
-
- if (_serial.escaped()) {
- _serial.clearEscaped();
- _serial.rxClear();
- serial_data_mode = false;
- _mode = mDot::COMMAND_MODE;
- logDebug("Exit Serial Mode");
- write(done);
- return;
- }
-
- if (!_dot->getNetworkJoinStatus()) {
- serial_data_mode = false;
- _mode = mDot::COMMAND_MODE;
- logDebug("Exit Serial Mode");
- write(no_carrier);
- return;
- }
-}
-
-bool CommandTerminal::autoJoinCheck() {
-
- std::string escape_buffer;
- int sleep = 1000;
- Timer tmr;
- tmr.start();
- int cnt = 0;
-
- while (!_dot->getNetworkJoinStatus()) {
- write("\r\nJoining network... ");
-
- if (_dot->getNextTxMs() > 0) {
- int rand_time = rand() % 10000;
- writef("\r\nWaiting %lu s before next join attempt\r\n", (_dot->getNextTxMs() + rand_time) / 1000);
-
- tmr.reset();
- while (_dot->getNextTxMs() > 0 && !_serial.escaped()) {
- osDelay(2);
- }
-
- tmr.reset();
- while (tmr.read_ms() < rand_time && !_serial.escaped())
- osDelay(10);
- }
-
- if (!_serial.escaped() && _dot->joinNetworkOnce() == mDot::MDOT_OK) {
- write("Network Joined\r\n");
- write(done);
- return false;
- }
-
- write("Network Join failed\r\n");
- write(error);
-
- if (!_serial.escaped() && _dot->getJoinRetries() > 0 && cnt++ > _dot->getJoinRetries()) {
- cnt = 0;
-
- if (_dot->getFrequencyBand() == mDot::FB_915) {
- uint8_t band = ((_dot->getFrequencySubBand()) % 8) + 1;
- logWarning("Join retries exhausted, switching to sub band %u", band);
- _dot->setFrequencySubBand(band);
- }
-
- if (sleep < 60 * 60 * 1000)
- sleep *= 2;
- }
-
- tmr.reset();
- while (tmr.read_ms() < sleep && !_serial.escaped()) {
- osDelay(10);
- }
-
- if (_serial.escaped()) {
- _serial.clearEscaped();
- serial_data_mode = false;
- _mode = mDot::COMMAND_MODE;
- write("Join Canceled\r\n");
- write(done);
- return true;
- }
- }
-
- return false;
-}
-
-void CommandTerminal::start() {
-
- 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;
- bool join_canceled = false;
-
- if (_dot->getStartUpMode() == mDot::SERIAL_MODE) {
-
- serial_data_mode = true;
- _mode = mDot::SERIAL_MODE;
-
- std::string escape_buffer;
- char ch;
-
- if (!_dot->getStandbyFlag()) {
- // wake up from power-on/reset
-
- int escape_timeout = 1000;
- Timer tmr;
- Timer escape_tmr;
-
- // wait one second for possible escape by user pressing '+' key
- 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("+") != std::string::npos) {
- logInfo("Escape detected");
- join_canceled = true;
- serial_data_mode = false;
- _mode = mDot::COMMAND_MODE;
- command.clear();
- break;
- }
-
- if (escape_tmr.read_ms() > escape_timeout)
- escape_buffer.clear();
-
- osDelay(1);
- }
- }
-
- if (_mode == mDot::SERIAL_MODE && !_dot->getNetworkJoinStatus() && _dot->getJoinMode() == mDot::OTA) {
- if (_dot->joinNetworkOnce() != mDot::MDOT_OK) {
- serial_data_mode = false;
- _mode = mDot::COMMAND_MODE;
-
- logWarning("Start Up Mode set to SERIAL_MODE, but join failed.");
- _serial.writef("Network Not Joined\r\n");
- _serial.writef(error);
- }
- }
- }
-
- if (_dot->getJoinMode() == mDot::PEER_TO_PEER) {
- peer_to_peer = true;
- } else {
- peer_to_peer = false;
- }
-
-
-
- //Run terminal session
- while (running) {
-
- // wait for input to reduce at command idle current
- while (!readable() || _mode == mDot::SERIAL_MODE) {
- 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
- serialLoop();
- continue;
- break;
- default:
- break;
- }
- }
-
- ch = '\0';
-
- wait(0.00001); // 10 us
- _serial.escaped();
- }
-
- // 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 = 0x00, ch2 = 0x00;
-
- if (readable()) {
- ch1 = read();
- if (readable())
- ch2 = read();
-
- if (ch1 == 0x5b && ch2 == 0x41) {
- // up key
- for (size_t i = 0; i < command.size() + 1; i++) {
- writef("\b \b");
- }
- if (history.size() > 0) {
- if (++history_index >= int(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 (size_t 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("ATE?") == 0 && args[0].length() == 4) || (args[0].find("ATE") == 0 && args[0].length() == 3)) {
- writef("%d\r\n", _dot->getEcho());
- write(done);
- } 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("ATV?") == 0 && args[0].length() == 4) || (args[0].find("ATV") == 0 && args[0].length() == 3)) {
- writef("%d\r\n", _dot->getVerbose());
- write(done);
- } 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].find("AT&K?") == 0 && args[0].length() == 5) || (args[0].find("AT&K") == 0 && args[0].length() == 4)) {
- writef("%d\r\n", (_dot->getFlowControl() ? 3 : 0));
- write(done);
- } else if (args[0].find("AT&K0") == 0 && args[0].length() == 5) {
- _dot->setFlowControl(false);
- write(done);
- } else if (args[0].find("AT&K3") == 0 && args[0].length() == 5) {
- _dot->setFlowControl(true);
- write(done);
- } else if (args[0] == "AT+SD") {
- if (_dot->getNetworkJoinStatus()) {
- logDebug("Enter Serial Mode");
- write(connect);
- serial_data_mode = true;
- _mode = mDot::SERIAL_MODE;
- } else {
- logDebug("Network Not Joined");
- write("Network Not Joined\r\n");
- write(error);
- }
- } else if (args[0] == "AT+SLEEP") {
- if (args.size() > 2 && (args[1] != "?")) {
- write("Invalid argument\r\n");
- write(error);
- } else {
- if (args.size() > 1 && args[1] == "?") {
- write("(0:deepsleep,1:sleep)\r\n");
- write(done);
- } else {
- _sleep_standby = !(args.size() > 1 && args[1] == "1");
- write(done);
- this->sleep(_sleep_standby);
- wait(0.1);
- }
- }
- } 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) {
- _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.start();
- while (timer.read_ms() < timeout) {
-
- if (dot != NULL) {
- if (wait == WAIT_SEND && (!dot->getIsTransmitting())) {
- return false;
- }
- }
-
- if (_serialp != NULL && _serialp->escaped()) {
- _serialp->clearEscaped();
- return true;
- }
-
- osDelay(10);
- }
-
- return false;
-}
-
-void CommandTerminal::wakeup(void) {
- if (_dot->getWakePin() == XBEE_DIN) {
- _serial.reattach(XBEE_DOUT, XBEE_DIN);
- logInfo("Wakeup pin was serial input");
- }
-}
-
-void CommandTerminal::RadioEvent::MacEvent(LoRaMacEventFlags* flags, LoRaMacEventInfo* info) {
-
- if (mts::MTSLog::getLogLevel() == mts::MTSLog::TRACE_LEVEL) {
- std::string msg = "OK";
- switch (info->Status) {
- case LORAMAC_EVENT_INFO_STATUS_ERROR:
- msg = "ERROR";
- break;
- case LORAMAC_EVENT_INFO_STATUS_TX_TIMEOUT:
- msg = "TX_TIMEOUT";
- break;
- case LORAMAC_EVENT_INFO_STATUS_RX_TIMEOUT:
- msg = "RX_TIMEOUT";
- break;
- case LORAMAC_EVENT_INFO_STATUS_RX_ERROR:
- msg = "RX_ERROR";
- break;
- case LORAMAC_EVENT_INFO_STATUS_JOIN_FAIL:
- msg = "JOIN_FAIL";
- break;
- case LORAMAC_EVENT_INFO_STATUS_DOWNLINK_FAIL:
- msg = "DOWNLINK_FAIL";
- break;
- case LORAMAC_EVENT_INFO_STATUS_ADDRESS_FAIL:
- msg = "ADDRESS_FAIL";
- break;
- case LORAMAC_EVENT_INFO_STATUS_MIC_FAIL:
- msg = "MIC_FAIL";
- break;
- default:
- break;
- }
- logTrace("Event: %s", msg.c_str());
-
- logTrace("Flags Tx: %d Rx: %d RxData: %d RxSlot: %d LinkCheck: %d JoinAccept: %d",
- flags->Bits.Tx, flags->Bits.Rx, flags->Bits.RxData, flags->Bits.RxSlot, flags->Bits.LinkCheck, flags->Bits.JoinAccept);
- logTrace("Info: Status: %d ACK: %d Retries: %d TxDR: %d RxPort: %d RxSize: %d RSSI: %d SNR: %d Energy: %d Margin: %d Gateways: %d",
- info->Status, info->TxAckReceived, info->TxNbRetries, info->TxDatarate, info->RxPort, info->RxBufferSize,
- info->RxRssi, info->RxSnr, info->Energy, info->DemodMargin, info->NbGateways);
- }
-
- if (flags->Bits.Rx) {
- if (serial_data_mode) {
- logDebug("Rx %d bytes", info->RxBufferSize);
- if (info->RxBufferSize > 0) {
- _serial.write((char*) info->RxBuffer, info->RxBufferSize);
- }
- }
- }
-}
-
-CommandTerminal::~CommandTerminal() {
- delete _events;
-}
+#include "ctype.h"
+#include "CommandTerminal.h"
+#include "Command.h"
+#include "MTSLog.h"
+#include <cstdarg>
+#include <deque>
+#if defined(TARGET_XDOT_L151CC)
+#include "xdot_low_power.h"
+#endif
+
+#if defined(TARGET_MTS_MDOT_F411RE)
+const char CommandTerminal::banner[] = "\r\n\nMultiTech Systems LoRa XBee Module\r\n\n";
+#else
+const char CommandTerminal::banner[] = "\r\n\nMultiTech Systems LoRa xDot Module\r\n\n";
+#endif
+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::connect[] = "\r\nCONNECT\r\n";
+const char CommandTerminal::no_carrier[] = "\r\nNO CARRIER\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::ATSerial* CommandTerminal::_serialp = NULL;
+mDot* CommandTerminal::_dot = NULL;
+
+CommandTerminal::RadioEvent* CommandTerminal::_events = new RadioEvent();
+
+static bool serial_data_mode = false;
+static bool peer_to_peer = false;
+
+std::string CommandTerminal::_errorMessage = "";
+
+void CommandTerminal::setErrorMessage(const char* message) {
+ _errorMessage.assign(message);
+}
+
+void CommandTerminal::setErrorMessage(const std::string& message) {
+ _errorMessage.assign(message);
+}
+
+const Command CommandTerminal::_commands[NO_OF_COMMANDS] = {
+ CmdAttention(),
+ CmdIdentification(),
+ CmdResetCpu(),
+ CmdDummy("Enable/Disable Echo", "ATE", "ATE0: disable, ATE1: enable", "(0,1)"),
+ CmdDummy("Enable/Disable Verbose", "ATV", "ATV0: disable, ATV1: enable", "(0,1)"),
+ CmdDummy("Hardware Flow Control", "AT&K", "AT&K0: disable, AT&K3: enable", "(0,3)"),
+
+ CmdFactoryDefault(),
+ CmdSaveConfig(),
+ CmdDisplayConfig(),
+ CmdDisplayStats(),
+ CmdResetStats(),
+ CmdSerialBaudRate(),
+ CmdDebugBaudRate(),
+ CmdStartUpMode(),
+
+ CmdFrequencyBand(),
+ CmdFrequencySubBand(),
+ CmdPublicNetwork(),
+ CmdDeviceId(),
+ CmdDeviceClass(),
+
+ CmdAppPort(),
+ CmdNetworkAddress(),
+ CmdNetworkSessionKey(),
+ CmdDataSessionKey(),
+ CmdUplinkCounter(),
+ CmdDownlinkCounter(),
+ CmdSaveSession(),
+ CmdRestoreSession(),
+ CmdNetworkKey(),
+ CmdNetworkId(),
+
+ CmdJoinDelay(),
+ CmdJoinRequest(),
+ CmdJoinRetries(),
+ CmdJoinByteOrder(),
+ CmdNetworkJoinMode(),
+ CmdPreserveSession(),
+ CmdNetworkJoinStatus(),
+ CmdNetworkLinkCheck(),
+ CmdLinkCheckCount(),
+ CmdLinkCheckThreshold(),
+ CmdEncryption(),
+
+ CmdRssi(),
+ CmdSnr(),
+ CmdDataPending(),
+
+ CmdSessionDataRate(),
+ CmdChannelMask(),
+
+ CmdTxDataRate(),
+ CmdTxPower(),
+ CmdAntennaGain(),
+ CmdTxFrequency(),
+ CmdTxInverted(),
+ CmdTxWait(),
+ CmdTxChannel(),
+ CmdTxNextMs(),
+ CmdTimeOnAir(),
+
+ CmdRxDelay(),
+ CmdRxOutput(),
+ CmdRxInverted(),
+
+ CmdErrorCorrection(),
+ CmdCRC(),
+ CmdAdaptiveDataRate(),
+
+ CmdACKAttempts(),
+ CmdRepeat(),
+ CmdMacCmd(),
+
+ CmdSendString(),
+ CmdSendBinary(),
+ CmdReceiveOnce(),
+
+ CmdDummy("Serial Data Mode", "AT+SD", "Enter serial data mode, exit with '+++'", "NONE"),
+ CmdDummy("Sleep Mode", "AT+SLEEP", "Enter sleep mode (0:deepsleep,1:sleep)", "(0,1)"),
+ CmdSerialClearOnError(),
+ CmdWakeMode(),
+ CmdWakeInterval(),
+ CmdWakePin(),
+ CmdWakeDelay(),
+ CmdWakeTimeout(),
+ CmdPing(),
+ CmdLogLevel(),
+
+ CmdDummy("***** Test Commands *****", "", "", ""),
+ CmdRxDataRate(),
+ CmdRxFrequency(),
+ CmdReceiveContinuous(),
+ CmdSendStringOnInterval(),
+};
+
+const verify_ptr_t CommandTerminal::_verify[NO_OF_COMMANDS] = {
+ CmdDummy::verify,
+ CmdDummy::verify,
+ CmdDummy::verify,
+ CmdDummy::verify,
+ CmdDummy::verify,
+ CmdDummy::verify,
+
+ CmdDummy::verify,
+ CmdDummy::verify,
+ CmdDummy::verify,
+ CmdDummy::verify,
+ CmdDummy::verify,
+ CmdSerialBaudRate::verify,
+ CmdDebugBaudRate::verify,
+ CmdStartUpMode::verify,
+
+ CmdFrequencyBand::verify,
+ CmdFrequencySubBand::verify,
+ CmdPublicNetwork::verify,
+ CmdDeviceId::verify,
+ CmdDeviceClass::verify,
+
+ CmdAppPort::verify,
+ CmdNetworkAddress::verify,
+ CmdNetworkSessionKey::verify,
+ CmdDataSessionKey::verify,
+ CmdUplinkCounter::verify,
+ CmdDownlinkCounter::verify,
+ CmdDummy::verify,
+ CmdDummy::verify,
+ CmdNetworkKey::verify,
+ CmdNetworkId::verify,
+
+ CmdJoinDelay::verify,
+ CmdJoinRequest::verify,
+ CmdJoinRetries::verify,
+ CmdJoinByteOrder::verify,
+ CmdNetworkJoinMode::verify,
+ CmdPreserveSession::verify,
+ CmdDummy::verify,
+ CmdDummy::verify,
+ CmdLinkCheckCount::verify,
+ CmdLinkCheckThreshold::verify,
+ CmdEncryption::verify,
+
+ CmdDummy::verify,
+ CmdDummy::verify,
+ CmdDummy::verify,
+
+ CmdSessionDataRate::verify,
+ CmdChannelMask::verify,
+
+ CmdTxDataRate::verify,
+ CmdTxPower::verify,
+ CmdAntennaGain::verify,
+ CmdTxFrequency::verify,
+ CmdTxInverted::verify,
+ CmdTxWait::verify,
+ CmdTxChannel::verify,
+ CmdTxNextMs::verify,
+ CmdTimeOnAir::verify,
+
+ CmdRxDelay::verify,
+ CmdRxOutput::verify,
+ CmdRxInverted::verify,
+
+ CmdErrorCorrection::verify,
+ CmdCRC::verify,
+ CmdAdaptiveDataRate::verify,
+
+ CmdACKAttempts::verify,
+ CmdRepeat::verify,
+ CmdMacCmd::verify,
+
+ CmdSendString::verify,
+ CmdSendBinary::verify,
+ CmdReceiveOnce::verify,
+
+ CmdDummy::verify,
+ CmdDummy::verify,
+ CmdSerialClearOnError::verify,
+ CmdWakeMode::verify,
+ CmdWakeInterval::verify,
+ CmdWakePin::verify,
+ CmdWakeDelay::verify,
+ CmdWakeTimeout::verify,
+ CmdDummy::verify,
+ CmdLogLevel::verify,
+
+ CmdDummy::verify,
+ CmdRxDataRate::verify,
+ CmdRxFrequency::verify,
+ CmdReceiveContinuous::verify,
+ CmdSendStringOnInterval::verify,
+};
+
+const action_ptr_t CommandTerminal::_action[NO_OF_COMMANDS] = {
+ CmdAttention::action,
+ CmdIdentification::action,
+ CmdResetCpu::action,
+ CmdDummy::action,
+ CmdDummy::action,
+ CmdDummy::action,
+
+ CmdFactoryDefault::action,
+ CmdSaveConfig::action,
+ CmdDisplayConfig::action,
+ CmdDisplayStats::action,
+ CmdResetStats::action,
+ CmdSerialBaudRate::action,
+ CmdDebugBaudRate::action,
+ CmdStartUpMode::action,
+
+ CmdFrequencyBand::action,
+ CmdFrequencySubBand::action,
+ CmdPublicNetwork::action,
+ CmdDeviceId::action,
+ CmdDeviceClass::action,
+
+ CmdAppPort::action,
+ CmdNetworkAddress::action,
+ CmdNetworkSessionKey::action,
+ CmdDataSessionKey::action,
+ CmdUplinkCounter::action,
+ CmdDownlinkCounter::action,
+ CmdSaveSession::action,
+ CmdRestoreSession::action,
+ CmdNetworkKey::action,
+ CmdNetworkId::action,
+
+ CmdJoinDelay::action,
+ CmdJoinRequest::action,
+ CmdJoinRetries::action,
+ CmdJoinByteOrder::action,
+ CmdNetworkJoinMode::action,
+ CmdPreserveSession::action,
+ CmdNetworkJoinStatus::action,
+ CmdNetworkLinkCheck::action,
+ CmdLinkCheckCount::action,
+ CmdLinkCheckThreshold::action,
+ CmdEncryption::action,
+
+ CmdRssi::action,
+ CmdSnr::action,
+ CmdDataPending::action,
+
+ CmdSessionDataRate::action,
+ CmdChannelMask::action,
+
+ CmdTxDataRate::action,
+ CmdTxPower::action,
+ CmdAntennaGain::action,
+ CmdTxFrequency::action,
+ CmdTxInverted::action,
+ CmdTxWait::action,
+ CmdTxChannel::action,
+ CmdTxNextMs::action,
+ CmdTimeOnAir::action,
+
+ CmdRxDelay::action,
+ CmdRxOutput::action,
+ CmdRxInverted::action,
+
+ CmdErrorCorrection::action,
+ CmdCRC::action,
+ CmdAdaptiveDataRate::action,
+
+ CmdACKAttempts::action,
+ CmdRepeat::action,
+ CmdMacCmd::action,
+
+ CmdSendString::action,
+ CmdSendBinary::action,
+ CmdReceiveOnce::action,
+
+ CmdDummy::action,
+ CmdDummy::action,
+ CmdSerialClearOnError::action,
+ CmdWakeMode::action,
+ CmdWakeInterval::action,
+ CmdWakePin::action,
+ CmdWakeDelay::action,
+ CmdWakeTimeout::action,
+ CmdPing::action,
+ CmdLogLevel::action,
+
+ CmdDummy::action,
+ CmdRxDataRate::action,
+ CmdRxFrequency::action,
+ CmdReceiveContinuous::action,
+ CmdSendStringOnInterval::action,
+
+};
+
+CommandTerminal::CommandTerminal(mts::ATSerial& serial) :
+ _serial(serial),
+ _mode(mDot::COMMAND_MODE),
+ _sleep_standby(true),
+#if defined(TARGET_MTS_MDOT_F411RE)
+ _xbee_on_sleep(XBEE_ON_SLEEP),
+#else
+ _xbee_on_sleep(GPIO2),
+#endif
+ _autoOTAEnabled(false),
+ _idle_thread(idle, NULL, osPriorityLow)
+{
+ _serialp = &serial;
+}
+
+void CommandTerminal::init() {
+ _dot->setEvents(_events);
+}
+
+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 (int i = 0; i < NO_OF_COMMANDS; i++) {
+ name = _commands[i].name();
+ text = _commands[i].text();
+ desc = _commands[i].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 _serialp->writeable();
+}
+
+bool CommandTerminal::readable() {
+ return _serialp->readable();
+}
+
+char CommandTerminal::read() {
+ char ch;
+ _serialp->read(&ch, 1);
+ return ch;
+}
+
+void CommandTerminal::write(const char* message) {
+ while (!writeable())
+ ;
+ _serialp->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())
+ ;
+ _serialp->write(buff, size);
+ va_end(ap);
+}
+
+void CommandTerminal::serialLoop() {
+ Timer serial_read_timer;
+ std::vector<uint8_t> serial_buffer;
+ std::vector<uint8_t> data;
+ int timeout = 0;
+
+ serial_read_timer.start();
+
+ if (_dot->getStartUpMode() == mDot::SERIAL_MODE) {
+ _xbee_on_sleep = GPIO_PIN_SET;
+
+ timeout = _dot->getWakeDelay();
+
+ // wait for timeout or start of serial data
+ while (!readable() && serial_read_timer.read_ms() < timeout && !_serialp->escaped()) {
+ osDelay(2);
+ }
+ }
+
+ if (!readable() && _events->SendAck()) {
+ logDebug("SERIAL NOT READABLE and ACK REQUESTED");
+ goto L_SEND;
+ }
+
+ if (readable() && !_serialp->escaped()) {
+
+ serial_read_timer.reset();
+ timeout = _dot->getWakeTimeout();
+
+ while (serial_read_timer.read_ms() < timeout && serial_buffer.size() <= _dot->getMaxPacketLength()) {
+ while (readable() && serial_buffer.size() < _dot->getMaxPacketLength()) {
+ serial_buffer.push_back(read());
+ serial_read_timer.reset();
+
+ if (_serialp->escaped())
+ break;
+ }
+ }
+
+ serial_read_timer.stop(), serial_read_timer.reset();
+
+ if (!serial_buffer.empty()) {
+ if (_dot->getStartUpMode() == mDot::SERIAL_MODE)
+ _xbee_on_sleep = GPIO_PIN_RESET;
+
+L_SEND:
+ // wait for any duty cycle limit to expire
+ while (_dot->getNextTxMs() > 0 && !_serialp->escaped()) {
+ osDelay(10);
+ }
+
+ if (_dot->getIsIdle()) {
+ logDebug("Received serial data, sending out radio.");
+
+ if (_dot->send(serial_buffer, false) != mDot::MDOT_OK) {
+ logDebug("Send failed.");
+ // If the data should be tossed after send failure, clear buffer
+ if (_dot->getSerialClearOnError()) {
+ serial_buffer.clear();
+ }
+ } else {
+
+ // wait for send to finish
+ while (!_dot->getIsIdle() && !_serialp->escaped()) {
+ osDelay(10);
+ }
+
+ // call recv to wait for any packet before sending again
+ if (!_serialp->escaped())
+ _dot->recv(data);
+
+ // Clear the serial buffer if send is success
+ serial_buffer.clear();
+
+ // In class C mode pending data will be sent automatically without uplink
+ if (_dot->getClass() != "C") {
+ if (_dot->getDataPending()) {
+ logDebug("Data is pending");
+ goto L_SEND;
+ }
+ if (_dot->getAckRequested()) {
+ logDebug("Ack requested");
+ goto L_SEND;
+ }
+ }
+ }
+ } else {
+ logDebug("Radio is busy, cannot send.\r\n");
+ osDelay(10);
+ }
+
+ } else {
+ logDebug("No data received from serial to send.\r\n");
+ }
+ }
+
+ if (!_serialp->readable() && _dot->getStartUpMode() == mDot::SERIAL_MODE && !_serialp->escaped()) {
+ sleep(true);
+ }
+
+ if (_serialp->escaped()) {
+ _serialp->clearEscaped();
+ _serialp->rxClear();
+ serial_data_mode = false;
+ _mode = mDot::COMMAND_MODE;
+ logDebug("Exit Serial Mode");
+ write(done);
+ return;
+ }
+
+ if (!_dot->getNetworkJoinStatus()) {
+ serial_data_mode = false;
+ _mode = mDot::COMMAND_MODE;
+ logDebug("Exit Serial Mode");
+ write(no_carrier);
+ return;
+ }
+}
+
+bool CommandTerminal::autoJoinCheck() {
+
+ std::string escape_buffer;
+ int sleep = 1000;
+ Timer tmr;
+ tmr.start();
+ int cnt = 0;
+
+ while (!_dot->getNetworkJoinStatus()) {
+ if (!serial_data_mode) {
+ write("\r\nJoining network... ");
+ }
+ logInfo("Joining network... ");
+
+ if (_dot->getNextTxMs() > 0) {
+ if (!serial_data_mode) {
+ writef("\r\nWaiting %lu s before next join attempt\r\n", _dot->getNextTxMs() / 1000);
+ }
+ logInfo("Waiting %lu s before next join attempt", _dot->getNextTxMs() / 1000);
+
+ tmr.reset();
+ while (_dot->getNextTxMs() > 0 && !_serial.escaped()) {
+ osDelay(20);
+ }
+ }
+
+ if (!_serial.escaped() && _dot->joinNetworkOnce() == mDot::MDOT_OK) {
+ if (!serial_data_mode) {
+ write("Network Joined\r\n");
+ write(done);
+ }
+ logInfo("Network Joined");
+ return false;
+ }
+
+ if (!serial_data_mode) {
+ write("Network Join failed\r\n");
+ write(error);
+ }
+ logInfo("Network Join failed");
+
+ if (!_serial.escaped() && _dot->getFrequencySubBand() != 0 && _dot->getJoinRetries() > 0 && cnt++ > _dot->getJoinRetries()) {
+ cnt = 0;
+
+ if (_dot->getFrequencyBand() == mDot::FB_US915 || _dot->getFrequencyBand() == mDot::FB_AU915 ) {
+ uint8_t band = ((_dot->getFrequencySubBand()) % 8) + 1;
+ logWarning("Join retries exhausted, switching to sub band %u", band);
+ _dot->setFrequencySubBand(band);
+ }
+ }
+
+ tmr.reset();
+ while (tmr.read_ms() < sleep && !_serial.escaped()) {
+ osDelay(10);
+ }
+
+ if (_serial.escaped()) {
+ _serial.clearEscaped();
+ serial_data_mode = false;
+ _mode = mDot::COMMAND_MODE;
+ if (!serial_data_mode) {
+ write("Join Canceled\r\n");
+ write(done);
+ }
+ logInfo("Join Canceled\r\n");
+ return true;
+ }
+ }
+
+ return false;
+}
+
+void CommandTerminal::start() {
+
+ 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;
+ bool join_canceled = false;
+
+ _autoOTAEnabled = _dot->getJoinMode() == mDot::AUTO_OTA;
+
+ if (_dot->getStartUpMode() == mDot::SERIAL_MODE) {
+
+ serial_data_mode = true;
+ _mode = mDot::SERIAL_MODE;
+
+ std::string escape_buffer;
+ char ch;
+
+ if (!_dot->getStandbyFlag()) {
+ // wake up from power-on/reset
+
+ int escape_timeout = 1000;
+ Timer tmr;
+ Timer escape_tmr;
+
+ // wait one second for possible escape by user pressing '+' key
+ 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("+") != std::string::npos) {
+ logInfo("Escape detected");
+ join_canceled = true;
+ serial_data_mode = false;
+ _mode = mDot::COMMAND_MODE;
+ command.clear();
+ break;
+ }
+
+ if (escape_tmr.read_ms() > escape_timeout)
+ escape_buffer.clear();
+
+ osDelay(1);
+ }
+ }
+
+ if (_mode == mDot::SERIAL_MODE && !_dot->getNetworkJoinStatus() && _dot->getJoinMode() == mDot::OTA) {
+ if (_dot->joinNetworkOnce() != mDot::MDOT_OK) {
+ serial_data_mode = false;
+ _mode = mDot::COMMAND_MODE;
+
+ logWarning("Start Up Mode set to SERIAL_MODE, but join failed.");
+ _serial.writef("Network Not Joined\r\n");
+ _serial.writef(error);
+ }
+ }
+ }
+
+ if (_dot->getJoinMode() == mDot::PEER_TO_PEER) {
+ peer_to_peer = true;
+ } else {
+ peer_to_peer = false;
+ }
+
+ //Run terminal session
+ while (running) {
+
+ // wait for input to reduce at command idle current
+ while (!readable() || _mode == mDot::SERIAL_MODE) {
+ if (!join_canceled && _autoOTAEnabled) {
+ join_canceled = autoJoinCheck();
+ if (join_canceled)
+ command.clear();
+ }
+
+ if (!_autoOTAEnabled || (!join_canceled && _autoOTAEnabled)) {
+ switch (_mode) {
+ case mDot::SERIAL_MODE:
+ // signal wakeup, read serial and output to radio
+ serialLoop();
+ continue;
+ break;
+ default:
+ break;
+ }
+ }
+
+ ch = '\0';
+
+ wait(0.00001); // 10 us
+ _serial.escaped();
+ }
+
+ // 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 = 0x00, ch2 = 0x00;
+
+ if (readable()) {
+ ch1 = read();
+ if (readable())
+ ch2 = read();
+
+ if (ch1 == 0x5b && ch2 == 0x41) {
+ // up key
+ for (size_t i = 0; i < command.size() + 1; i++) {
+ writef("\b \b");
+ }
+ if (history.size() > 0) {
+ if (++history_index >= int(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 (size_t 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("ATE?") == 0 && args[0].length() == 4) || (args[0].find("ATE") == 0 && args[0].length() == 3)) {
+ writef("%d\r\n", _dot->getEcho());
+ write(done);
+ } 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("ATV?") == 0 && args[0].length() == 4) || (args[0].find("ATV") == 0 && args[0].length() == 3)) {
+ writef("%d\r\n", _dot->getVerbose());
+ write(done);
+ } 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].find("AT&K?") == 0 && args[0].length() == 5) || (args[0].find("AT&K") == 0 && args[0].length() == 4)) {
+ writef("%d\r\n", (_dot->getFlowControl() ? 3 : 0));
+ write(done);
+ } else if (args[0].find("AT&K0") == 0 && args[0].length() == 5) {
+ _dot->setFlowControl(false);
+ write(done);
+ } else if (args[0].find("AT&K3") == 0 && args[0].length() == 5) {
+ _dot->setFlowControl(true);
+ write(done);
+ } else if (args[0] == "AT+SD") {
+ if (_dot->getNetworkJoinStatus()) {
+ logDebug("Enter Serial Mode");
+ write(connect);
+ serial_data_mode = true;
+ _mode = mDot::SERIAL_MODE;
+ } else {
+ logDebug("Network Not Joined");
+ write("Network Not Joined\r\n");
+ write(error);
+ }
+ } else if (args[0] == "AT+SLEEP") {
+ if (args.size() > 2 && (args[1] != "?")) {
+ write("Invalid argument\r\n");
+ write(error);
+ } else {
+ if (args.size() > 1 && args[1] == "?") {
+ write("(0:deepsleep,1:sleep)\r\n");
+ write(done);
+ } else {
+ _sleep_standby = !(args.size() > 1 && args[1] == "1");
+ write(done);
+ this->sleep(_sleep_standby);
+ wait(0.1);
+ }
+ }
+ } 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 (int i = 0; i < NO_OF_COMMANDS; i++) {
+
+ // match CMD or CMD? syntax if command is queryable
+ if (lookfor == _commands[i].text() && (!query || (query && _commands[i].queryable()))) {
+ found = true;
+ if (args[0] == "HELP") {
+ writef("%s%s", _commands[i].help().c_str(), newline);
+ write(done);
+ }
+
+ else if (args.size() > 1 && args[1] == "?") {
+ writef("%s%s", _commands[i].usage().c_str(), newline);
+ write(done);
+ } else if (!_verify[i](args)) {
+ writef("%s%s", _errorMessage.c_str(), newline);
+ writef("%s", error);
+ } else {
+ if (_action[i](args) == 0) {
+ writef("%s", done);
+ } else {
+ writef("%s%s", _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();
+ }
+}
+
+void CommandTerminal::sleep(bool standby) {
+ _xbee_on_sleep = GPIO_PIN_RESET;
+
+ _serial.rxClear();
+ _serial.txClear();
+
+#if defined(TARGET_XDOT_L151CC)
+ xdot_save_gpio_state();
+
+ /* GPIO Ports Clock Enable */
+ __GPIOA_CLK_ENABLE();
+ __GPIOB_CLK_ENABLE();
+ __GPIOC_CLK_ENABLE();
+ __GPIOH_CLK_ENABLE();
+
+ GPIO_InitTypeDef GPIO_InitStruct;
+
+ // UART1_TX, UART1_RTS & UART1_CTS to analog nopull - RX could be a wakeup source
+ GPIO_InitStruct.Pin = GPIO_PIN_9 | GPIO_PIN_11 | GPIO_PIN_12;
+ GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
+ GPIO_InitStruct.Pull = GPIO_NOPULL;
+ HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
+
+ // I2C_SDA & I2C_SCL to analog nopull
+ GPIO_InitStruct.Pin = GPIO_PIN_8 | GPIO_PIN_9;
+ GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
+ GPIO_InitStruct.Pull = GPIO_NOPULL;
+ HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
+
+ // SPI_MOSI, SPI_MISO, SPI_SCK, & SPI_NSS to analog nopull
+ GPIO_InitStruct.Pin = GPIO_PIN_12 | GPIO_PIN_13 | GPIO_PIN_14 | GPIO_PIN_15;
+ GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
+ GPIO_InitStruct.Pull = GPIO_NOPULL;
+ HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
+
+ // iterate through potential wake pins - leave the configured wake pin alone if one is needed
+ if (_dot->getWakePin() != WAKE || _dot->getWakeMode() == mDot::RTC_ALARM) {
+ GPIO_InitStruct.Pin = GPIO_PIN_0;
+ GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
+ GPIO_InitStruct.Pull = GPIO_NOPULL;
+ HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
+ }
+ if (_dot->getWakePin() != GPIO0 || _dot->getWakeMode() == mDot::RTC_ALARM) {
+ GPIO_InitStruct.Pin = GPIO_PIN_4;
+ GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
+ GPIO_InitStruct.Pull = GPIO_NOPULL;
+ HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
+ }
+ if (_dot->getWakePin() != GPIO1 || _dot->getWakeMode() == mDot::RTC_ALARM) {
+ GPIO_InitStruct.Pin = GPIO_PIN_5;
+ GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
+ GPIO_InitStruct.Pull = GPIO_NOPULL;
+ HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
+ }
+ if (_dot->getWakePin() != GPIO2 || _dot->getWakeMode() == mDot::RTC_ALARM) {
+ GPIO_InitStruct.Pin = GPIO_PIN_0;
+ GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
+ GPIO_InitStruct.Pull = GPIO_NOPULL;
+ HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
+ }
+ if (_dot->getWakePin() != GPIO3 || _dot->getWakeMode() == mDot::RTC_ALARM) {
+ GPIO_InitStruct.Pin = GPIO_PIN_2;
+ GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
+ GPIO_InitStruct.Pull = GPIO_NOPULL;
+ HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
+ }
+ if (_dot->getWakePin() != UART1_RX || _dot->getWakeMode() == mDot::RTC_ALARM) {
+ GPIO_InitStruct.Pin = GPIO_PIN_10;
+ GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
+ GPIO_InitStruct.Pull = GPIO_NOPULL;
+ HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
+ }
+#endif
+
+ _dot->sleep(_dot->getWakeInterval(), _dot->getWakeMode(), standby);
+
+#if defined(TARGET_XDOT_L151CC)
+ xdot_restore_gpio_state();
+#endif
+}
+
+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());
+}
+
+bool CommandTerminal::waitForEscape(int timeout, mDot* dot, WaitType wait) {
+ Timer timer;
+
+ timer.start();
+ while (timer.read_ms() < timeout) {
+
+ if (dot != NULL) {
+ if (wait == WAIT_SEND && (!dot->getIsTransmitting())) {
+ return false;
+ }
+ }
+
+ if (_serialp != NULL && _serialp->escaped()) {
+ _serialp->clearEscaped();
+ return true;
+ }
+
+ osDelay(10);
+ }
+
+ return false;
+}
+
+void CommandTerminal::wakeup(void) {
+}
+
+void CommandTerminal::RadioEvent::PacketRx(uint8_t port, uint8_t *payload, uint16_t size, int16_t rssi, int8_t snr, lora::DownlinkControl ctrl, uint8_t slot, uint8_t retries) {
+ mDotEvent::PacketRx(port, payload, size, rssi, snr, ctrl, retries);
+
+ if (serial_data_mode) {
+ logDebug("Rx %d bytes", size);
+ if (size > 0) {
+ CommandTerminal::Serial()->write((char*) RxPayload, RxPayloadSize);
+ }
+ if (!CommandTerminal::Serial()->readable() && _dot->getAckRequested() && _dot->getClass() == "C") {
+ _sendAck = true;
+ }
+ }
+}
+
+CommandTerminal::~CommandTerminal() {
+ delete _events;
+}
+