Diff: ATSerial.cpp

Revision:

28:c222ca8383f4

Parent:

27:5fafd3b26ac3

Child:

36:b586cd6e91f3

--- a/ATSerial.cpp	Fri Sep 11 13:16:33 2020 -0500
+++ b/ATSerial.cpp	Thu Nov 19 09:58:25 2020 -0600
@@ -1,117 +1,213 @@
-#include "mbed.h"
+
 #include "ATSerial.h"
 #include "MTSLog.h"
+#include "Utils.h"
 
 using namespace mts;
 
-ATSerial::ATSerial(PinName TXD, PinName RXD, int txBufferSize, int rxBufferSize)
-    : MTSBufferedIO(txBufferSize, rxBufferSize)
-    , _serial(new RawSerial(TXD,RXD)),
-    _baudrate(9600),
-    _bits(8),
-    _parity(mbed::SerialBase::None),
-    _stop_bits(1),
+
+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)
+    _escaped(false),
+    _flow(false),       // Flow control disabled by default
+    _rts(rts),
+    _cts(cts)
 {
-    timer.start();
-    _serial->attach(callback(this, &ATSerial::handleRead), Serial::RxIrq);
+    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()
 {
-    delete _serial;
+}
+
+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();
 }
 
-
-
-void ATSerial::baud(int baudrate)
-{
-    _baudrate = baudrate;
-    _serial->baud(_baudrate);
+bool ATSerial::read(char& c) {
+    return read(&c, 1) == 1;
 }
 
-void ATSerial::format(int bits, SerialBase::Parity parity, int stop_bits)
+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()
 {
-    _bits = bits;
-    _parity = parity;
-    _stop_bits = stop_bits;
-    _serial->format(_bits, _parity, _stop_bits);
+    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()
-{
-    while(txBuffer.size() != 0) {
-        if (_serial->writeable()) {
-            char byte;
-            if(txBuffer.read(byte) == 1) {
-                _serial->attach(NULL, Serial::RxIrq);
-                _serial->putc(byte);
-                _serial->attach(callback(this, &ATSerial::handleRead), Serial::RxIrq);
-            }
+{ 
+    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 {
-            return;
+            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 mts::ATSerial::reattach(PinName TXD, PinName RXD) {
-    delete _serial;
-    _serial = new RawSerial(TXD, RXD);
-    _serial->attach(callback(this, &ATSerial::handleRead), Serial::RxIrq);
-    _serial->baud(_baudrate);
-    _serial->format(_bits, _parity, _stop_bits);
-    rxBuffer.clear();
-    txBuffer.clear();
-}
-
-void mts::ATSerial::sendBreak() {
-    _serial->send_break();
-}
-
-bool ATSerial::escaped() {
-
-    int now = timer.read_ms();
-
-    // Have we seen three esc chars and 1 sec end guard has passed
-    if (_escaped || (_esc_cnt == 3 && (now - _last_time > 1000))) {
-        _escaped = true;
-        return true;
-
-    // Have we seen a couple esc chars but nothing in 500 ms
-    } else if (_esc_cnt > 0 && _esc_cnt != 3 && now - _last_time > 500) {
-        // Write seen esc chars
-        while (_esc_cnt) {
-            rxBuffer.write(_esc_ch);
-            _esc_cnt--;
-        }
-    }
-
-    return false;
-}
-
-void ATSerial::clearEscaped() {
-    _esc_cnt = 0;
-    _escaped = false;
-}
 
 void ATSerial::handleRead()
 {
-    char byte = _serial->getc();
-    int now = timer.read_ms();
+    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 && (now - _last_time < 1000)) {
+    if (_esc_cnt == 3 && (elapsed_ms < std::chrono::seconds(1))) {
         // Write the three chars we held back
         while (_esc_cnt) {
-            rxBuffer.write(_esc_ch);
+            _rxbuf.push(_esc_ch);
             _esc_cnt--;
         }
     } else if (byte == _esc_ch) {
         // Has 1 second passed before last char
-        if (now - _last_time > 1000) {
+        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) {
@@ -120,16 +216,24 @@
     } else if (_esc_cnt > 0) {
         // Write any esc chars held back
         while (_esc_cnt) {
-            rxBuffer.write(_esc_ch);
+            _rxbuf.push(_esc_ch);
             _esc_cnt--;
         }
     }
 
-    if(_esc_cnt == 0 && rxBuffer.write(byte) != 1) {
-        // logError("Serial Rx Byte Dropped [%c][0x%02X]", byte, byte);
+    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);
+        }
     }
 
-    _last_time = timer.read_ms();
 }
 
 void ATSerial::escapeChar(char esc) {
@@ -140,13 +244,3 @@
     return _esc_ch;
 }
 
-void ATSerial::attach() {
-    if (_serial)
-        _serial->attach(callback(this, &ATSerial::handleRead), Serial::RxIrq);
-    rxBuffer.write('\r');
-}
-
-void ATSerial::detach() {
-    if (_serial)
-        _serial->attach(NULL, Serial::RxIrq);
-}