AT command firmware for MultiTech Dot devices.

Fork of mDot_AT_firmware by MultiTech

Dot Library Not Included!

Because these example programs can be used for both mDot and xDot devices, the LoRa stack is not included. The libmDot library should be imported if building for mDot devices. The libxDot library should be imported if building for xDot devices. The AT firmware was last tested with mbed-os-5.4.7. Using a version past mbed-os-5.4.7 will cause the build to fail. The library used with the AT firmware has to match the mbed-os version.

Dot Library Version 3 Updates

Dot Library versions 3.x.x require a channel plan to be injected into the stack. The Dot-Examples and Dot-AT-Firmware do this by defining a macro called "CHANNEL_PLAN" that controls the channel plan that will be used in the examples. Available channel plans will be in the Dot Library repository in the plans folder.

Revision 20 and earlier of Dot-Examples and revision 15 and earlier of Dot-AT-Firmware should be used with Dot Library versions prior to 3.0.0.

Fota Library

Th Fota Library must be added to compile for mDot 3.1.0 with Fota support. Latest dev libraries and 3.2.0 release will include Fota with libmDot/libxDot.

AT Firmware Description

This AT Firmware is what ships on mDot and xDot devices. It provides an AT command interface for using the mDot or xDot for LoRa communication.

AT command documentation can be found on Multitech.com.

The firmware changelog can be found here. The library changelog can be found here.

Dot Libraries

Dot Library Limitations

The commit messages in libmDot-mbed5 and libmDot-dev-mbed5 specify the version of the Dot library the commit contains and the version of mbed-os it was compiled against. We recommend building your application with the version of mbed-os specified in the commit message of the version of the Dot library you're using. This will ensure that you don't run into any runtime issues caused by differences in the mbed-os versions.

Stable and development libraries are available for both mDot and xDot platforms. The library chosen must match the target platform. Compiling for the mDot platform with the xDot library or vice versa will not succeed.

mDot Library

Development library for mDot.

libmDot-dev-mbed5

Stable library for mDot.

Import librarylibmDot-mbed5

Stable version of the mDot library for mbed 5. This version of the library is suitable for deployment scenarios. See lastest commit message for version of mbed-os library that has been tested against.

xDot Library

Development library for xDot.

libxDot-dev-mbed5

Stable library for xDot.

Import librarylibxDot-mbed5

Stable version of the xDot library for mbed 5. This version of the library is suitable for deployment scenarios.

ATSerial.cpp

Committer:
Jason Reiss
Date:
4 months ago
Revision:
33:5c0252521669
Parent:
28:c222ca8383f4

File content as of revision 33:5c0252521669:


#include "ATSerial.h"
#include "MTSLog.h"
#include "Utils.h"

using namespace mts;


ATSerial::ATSerial(PinName txd, PinName rxd, PinName rts, PinName cts, int baud)
    : _serial(txd, rxd, baud),
    _tx_irq_enabled(false),
    _last_time(0),
    _esc_cnt(0),
    _esc_ch('+'),
    _escaped(false),
    _flow(false),       // Flow control disabled by default
    _rts(rts),
    _cts(cts)
{
    if (rts != NC && cts != NC) {   // RTS and CTS must both be provided for flow control
        _flow = true;
        _rts = 0;   // Start with receive enabled
        _cts.fall(callback(this, &ATSerial::startWrite));   // Restart writes when able to send
        _hwm = mts_max(MBED_CONF_DRIVERS_UART_SERIAL_RXBUF_SIZE - 10, MBED_CONF_DRIVERS_UART_SERIAL_RXBUF_SIZE * 0.85);
        _lwm = MBED_CONF_DRIVERS_UART_SERIAL_RXBUF_SIZE * 0.3;
    }
    _timer.start();
    _serial.attach(callback(this, &ATSerial::handleRead), SerialBase::RxIrq);
}

ATSerial::~ATSerial()
{
}

void ATSerial::baud(int baudrate) {
    _mutex.lock();
    _serial.baud(baudrate);
    _mutex.unlock();
}

void ATSerial::format(int bits, SerialBase::Parity parity, int stop_bits) {
    _mutex.lock();
    _serial.format(bits, parity, stop_bits);
    _mutex.unlock();
}
 
bool ATSerial::readable() {
    return !_rxbuf.empty();
}

bool ATSerial::writeable() {
    return !_txbuf.full();
}

void ATSerial::rxClear() {
    _mutex.lock();
    _rxbuf.reset();
    if (_flow) {
        _rts = 0;   // Allow receiving because receive buffer is now empty
    }
    _mutex.unlock();
}

void ATSerial::txClear() {
    _mutex.lock();
    _txbuf.reset();
    _mutex.unlock();
}

bool ATSerial::escaped() {
    _mutex.lock();
    std::chrono::milliseconds now = std::chrono::duration_cast<std::chrono::milliseconds>(_timer.elapsed_time());
    std::chrono::milliseconds elapsed_ms = now - _last_time;

    // Have we seen three esc chars and 1 sec end guard has passed
    if (_escaped || (_esc_cnt == 3 && (elapsed_ms > 1s))) {
        _escaped = true;

    // Have we seen a couple esc chars but nothing in 500 ms
    } else if (_esc_cnt > 0 && _esc_cnt != 3 && elapsed_ms > 500ms) {
        // Write seen esc chars
        while (_esc_cnt) {
            _rxbuf.push(_esc_ch);
            _esc_cnt--;
        }
        _escaped = false;
    }
    _mutex.unlock();

    return _escaped;
}

void ATSerial::clearEscaped() {
    _mutex.lock();
    _esc_cnt = 0;
    _escaped = false;
    _mutex.unlock();
}

bool ATSerial::read(char& c) {
    return read(&c, 1) == 1;
}

int ATSerial::write(const char *buffer, size_t length) {
    _mutex.lock();
    size_t i = 0;
    while (i < length) {
        if (_txbuf.full()) {
            do {
                _mutex.unlock();
                thread_sleep_for(1);
                _mutex.lock();
            } while (_txbuf.full());
        }
        while (i < length && !_txbuf.full())
        {
            _txbuf.push(buffer[i]);
            i++;
        }
        startWrite();   // Start writing data in tx buffer
    }
    _mutex.unlock();
    return i;
}
    
int ATSerial::writef(const char* format, ... ) {
    char buff[256];

    va_list ap;
    va_start(ap, format);
    int size = vsnprintf(buff, 256, format, ap);
    int n = write(buff, size);
    va_end(ap);

    return n;
}

int ATSerial::read(char *buffer, size_t length) {
    _mutex.lock();
    size_t r = 0;
    while (r < length) {
        if (_rxbuf.pop(buffer[r])) {
            r++;
        } else {
            break;
        }
    }
    if (_flow && _rts && _rxbuf.size() <= _lwm) {
        _rts = 0;   // RX buffer has room, clear RTS to continue receiving
    }
    _mutex.unlock();
    return r;
}

void ATSerial::startWrite()
{
    core_util_critical_section_enter();
    if (!_tx_irq_enabled) {
        // only write to hardware in one place
        handleWrite();
        if (!_txbuf.empty()) {
            _serial.attach(callback(this, &ATSerial::handleWrite), SerialBase::TxIrq);
            _tx_irq_enabled = true;
        }
    }
    core_util_critical_section_exit();
}

void ATSerial::handleWrite()
{ 
    char c;
    while (_serial.writeable()) {
        if (_flow && _cts) {
            break;  // Exit write loop when CTS is set, will resume when it is cleared
        }

        if (_txbuf.pop(c)) {
            _serial.write(&c, 1);
        } else {
            break;
        }
    }

    // Detach TX IRQ if there's no more data to write or CTS is set
    if (_tx_irq_enabled && (_txbuf.empty() || (_flow && _cts))) {
        _serial.attach(NULL, SerialBase::TxIrq);
        _tx_irq_enabled = false;
    }
}


void ATSerial::handleRead()
{
    char byte;
    if (_serial.read(&byte, 1) < 1) { return; }

    std::chrono::milliseconds now = std::chrono::duration_cast<std::chrono::milliseconds>(_timer.elapsed_time());
    std::chrono::milliseconds elapsed_ms = now - _last_time;
    _last_time = now;
    
    // Have we seen 3 esc chars but this char is before 1 sec end guard time
    if (_esc_cnt == 3 && (elapsed_ms < std::chrono::seconds(1))) {
        // Write the three chars we held back
        while (_esc_cnt) {
            _rxbuf.push(_esc_ch);
            _esc_cnt--;
        }
    } else if (byte == _esc_ch) {
        // Has 1 second passed before last char
        if (elapsed_ms > std::chrono::seconds(1)) {
            _esc_cnt = 1;
        // Is this second or third esc char
        } else if (_esc_cnt > 0 && _esc_cnt < 3) {
            _esc_cnt++;
        }
    } else if (_esc_cnt > 0) {
        // Write any esc chars held back
        while (_esc_cnt) {
            _rxbuf.push(_esc_ch);
            _esc_cnt--;
        }
    }

    if(_esc_cnt == 0) {
        if (_flow && !_rts && _rxbuf.size() >= _hwm) {
            _rts = 1;   // RX buffer too full, set RTS to stop receiving
                        // Data will still be received until the buffer is full
        }

        if (_rxbuf.full()) {
            // Overflow, drop byte
        } else {
            _rxbuf.push(byte);
        }
    }

}

void ATSerial::escapeChar(char esc) {
    _esc_ch = esc;
}

char ATSerial::escapeChar() {
    return _esc_ch;
}