Allow rewinding of commands sent via UART buffer

FluidNC/src/FixedCircularBuffer.h

@@ -0,0 +1,61 @@
+// Copyright (c) 2024 - Dylan Knutson <[email protected]>
+// Use of this source code is governed by a GPLv3 license that can be found in the LICENSE file.
+
+#pragma once
+
+#include <vector>
+#include <optional>
+
+/**
+ * A fixed-size circular buffer that stores elements of type T.
+ * Keeps track of how many elements have been pushed onto it, and allows
+ * for indexing as if it was an infinite sized array. If indexing into
+ * the buffer would result in an out-of-bounds access, returns std::nullopt.
+ *
+ * This is useful for implementing "scrollback" of a buffer of e.g. user
+ * provided commands, without using an unbounded amount of memory.
+ */
+template <typename T>
+class FixedCircularBuffer {
+public:
+    std::vector<T> storage;
+    std::size_t    head_idx, tail_idx;
+
+public:
+    FixedCircularBuffer() : FixedCircularBuffer(0) {}
+    FixedCircularBuffer(size_t size) : storage(size), head_idx(0), tail_idx(0) {}
+
+    /**
+     * Push an element onto the end of the buffer.
+     */
+    void push(T&& elem) {
+        storage[tail_idx % storage.size()] = std::move(elem);
+        tail_idx += 1;
+        if (tail_idx - head_idx > storage.size()) {
+            head_idx += 1;
+        }
+    }
+
+    /**
+     * Get the element at the given index, or std::nullopt if the index is out of bounds.
+     */
+    std::optional<T> at(std::size_t idx) const {
+        if (idx >= tail_idx) {
+            return std::nullopt;
+        }
+        if (idx < head_idx) {
+            return std::nullopt;
+        }
+        return storage[idx % storage.size()];
+    }
+
+    /**
+     * Is the buffer empty?
+     */
+    bool is_empty() const { return head_idx == tail_idx; }
+
+    /**
+     * Get the index of the last element pushed onto the buffer.
+     */
+    std::size_t position() const { return tail_idx; }
+};

FluidNC/src/Flowcontrol.cpp

@@ -233,8 +233,10 @@ Error flowcontrol(uint32_t o_label, char* line, size_t& pos, bool& skip) {
         case Op_Repeat:
             if (Job::active()) {
                 if (!skipping && (status = expression(line, pos, value)) == Error::Ok) {
-                    stack_push(o_label, operation, !value);
-                    if (value) {
+                    // TODO - return an error if value < 0
+                    // For now, just guard against negative values
+                    stack_push(o_label, operation, !(value > 0.0));
+                    if (value > 0.0) {
                         context.top().file     = Job::source();
                         context.top().file_pos = context.top().file->position();
                         context.top().repeats  = (uint32_t)value;
@@ -249,7 +251,7 @@ Error flowcontrol(uint32_t o_label, char* line, size_t& pos, bool& skip) {
             if (Job::active()) {
                 if (last_op == Op_Repeat) {
                     if (o_label == context.top().o_label) {
-                        if (context.top().repeats && --context.top().repeats) {
+                        if (context.top().repeats && --context.top().repeats > 0.0) {
                             context.top().file->set_position(context.top().file_pos);
                         } else {
                             stack_pull();

FluidNC/src/Job.cpp

@@ -4,17 +4,29 @@
 #include "Job.h"
 #include <map>
 #include <stack>
+#include "Protocol.h"
 
 std::stack<JobSource*> job;
 
 Channel* Job::leader = nullptr;
 
 bool Job::active() {
-    return !job.empty();
+    return !job.empty() || activeChannel;
 }
 
+JobSource activeChannelJobSource(nullptr);
+
 JobSource* Job::source() {
-    return job.empty() ? nullptr : job.top();
+    if (job.empty()) {
+        if (activeChannel) {
+            activeChannelJobSource.set_channel(activeChannel);
+            return &activeChannelJobSource;
+        } else {
+            return nullptr;
+        }
+    } else {
+        return job.top();
+    }
 }
 
 // save() and restore() are use to close/reopen an SD file atop the job stack
@@ -38,9 +50,11 @@ void Job::nest(Channel* in_channel, Channel* out_channel) {
     job.push(source);
 }
 void Job::pop() {
-    auto source = job.top();
-    job.pop();
-    delete source;
+    if (!job.empty()) {
+        auto source = job.top();
+        job.pop();
+        delete source;
+    }
     if (!active()) {
         leader = nullptr;
     }
@@ -60,14 +74,14 @@ void Job::abort() {
 }
 
 bool Job::get_param(const std::string& name, float& value) {
-    return job.top()->get_param(name, value);
+    return source()->get_param(name, value);
 }
 bool Job::set_param(const std::string& name, float value) {
-    return job.top()->set_param(name, value);
+    return source()->set_param(name, value);
 }
 bool Job::param_exists(const std::string& name) {
-    return job.top()->param_exists(name);
+    return source()->param_exists(name);
 }
 Channel* Job::channel() {
-    return job.top()->channel();
+    return source()->channel();
 }

FluidNC/src/Job.h

@@ -31,6 +31,7 @@ class JobSource {
     void   set_position(size_t pos) { _channel->set_position(pos); }
 
     Channel* channel() { return _channel; }
+    void     set_channel(Channel* channel) { _channel = channel; }
 
     ~JobSource() { delete _channel; }
 };

FluidNC/src/Protocol.h

@@ -50,6 +50,8 @@ extern volatile bool rtCycleStop;
 
 extern volatile bool runLimitLoop;
 
+extern Channel* activeChannel;
+
 // Alarm codes.
 enum class ExecAlarm : uint8_t {
     None                  = 0,

FluidNC/src/UartChannel.cpp

@@ -6,8 +6,10 @@
 #include "Serial.h"                 // allChannels
 
 UartChannel::UartChannel(int num, bool addCR) : Channel("uart_channel", num, addCR) {
-    _lineedit = new Lineedit(this, _line, Channel::maxLine - 1);
-    _active   = false;
+    _lineedit           = new Lineedit(this, _line, Channel::maxLine - 1);
+    _active             = false;
+    _history_buffer     = FixedCircularBuffer<char>(512);
+    _history_buffer_pos = 0;
 }
 
 void UartChannel::init() {
@@ -63,10 +65,13 @@ size_t UartChannel::write(const uint8_t* buffer, size_t length) {
 }
 
 int UartChannel::available() {
-    return _uart->available();
+    return (_history_buffer_pos < _history_buffer.position()) || _uart->available();
 }
 
 int UartChannel::peek() {
+    if (_history_buffer_pos < _history_buffer.position()) {
+        return _history_buffer.at(_history_buffer_pos).value();
+    }
     return _uart->peek();
 }
 
@@ -90,12 +95,22 @@ bool UartChannel::lineComplete(char* line, char c) {
 }
 
 int UartChannel::read() {
+    if (_history_buffer_pos < _history_buffer.position()) {
+        int c = _history_buffer.at(_history_buffer_pos).value();
+        _history_buffer_pos += 1;
+        return c;
+    }
+
     int c = _uart->read();
     if (c == 0x11) {
         // 0x11 is XON.  If we receive that, it is a request to use software flow control
         _uart->setSwFlowControl(true, -1, -1);
         return -1;
     }
+    if (c != -1) {
+        _history_buffer.push((char)c);
+        _history_buffer_pos += 1;
+    }
     return c;
 }
 

FluidNC/src/UartChannel.h

@@ -6,11 +6,14 @@
 #include "Uart.h"
 #include "Channel.h"
 #include "lineedit.h"
+#include "FixedCircularBuffer.h"
 
 class UartChannel : public Channel, public Configuration::Configurable {
 private:
-    Lineedit* _lineedit;
-    Uart*     _uart;
+    Lineedit*                 _lineedit;
+    Uart*                     _uart;
+    FixedCircularBuffer<char> _history_buffer;
+    std::size_t               _history_buffer_pos;
 
     int _uart_num           = 0;
     int _report_interval_ms = 0;
@@ -49,6 +52,9 @@ class UartChannel : public Channel, public Configuration::Configurable {
         handler.item("uart_num", _uart_num);
         handler.item("message_level", _message_level, messageLevels2);
     }
+
+    size_t position() override { return _history_buffer_pos; }
+    void   set_position(size_t pos) override { _history_buffer_pos = pos; }
 };
 
 extern UartChannel Uart0;

FluidNC/tests/FixedCircularBufferTest.cpp

@@ -0,0 +1,42 @@
+// Copyright (c) 2024 - Dylan Knutson <[email protected]>
+// Use of this source code is governed by a GPLv3 license that can be found in the LICENSE file.
+
+#include "gtest/gtest.h"
+#include "src/FixedCircularBuffer.h"
+
+TEST(FixedCircularBuffer, Empty) {
+    FixedCircularBuffer<int> buffer(0);
+
+    ASSERT_TRUE(buffer.is_empty());
+    ASSERT_EQ(buffer.position(), 0);
+    ASSERT_EQ(buffer.at(0), std::nullopt);
+    ASSERT_EQ(buffer.at(1), std::nullopt);
+    ASSERT_EQ(buffer.at(2), std::nullopt);
+}
+
+TEST(FixedCircularBuffer, OneElement) {
+    FixedCircularBuffer<int> buffer(1);
+
+    buffer.push(42);
+
+    ASSERT_FALSE(buffer.is_empty());
+    ASSERT_EQ(buffer.position(), 1);
+    ASSERT_EQ(buffer.at(0), 42);
+    ASSERT_EQ(buffer.at(1), std::nullopt);
+    ASSERT_EQ(buffer.at(2), std::nullopt);
+}
+
+TEST(FixedCircularBuffer, FrontElementsPopped) {
+    FixedCircularBuffer<int> buffer(2);
+
+    buffer.push(1);
+    buffer.push(2);
+    buffer.push(3);
+
+    ASSERT_FALSE(buffer.is_empty());
+    ASSERT_EQ(buffer.position(), 3);
+    ASSERT_EQ(buffer.at(0), std::nullopt);
+    ASSERT_EQ(buffer.at(1), 2);
+    ASSERT_EQ(buffer.at(2), 3);
+    ASSERT_EQ(buffer.at(3), std::nullopt);
+}

fixture_tests/fixtures/flow_control_repeat.nc

@@ -0,0 +1,45 @@
+ignore ok
+
+# test repeat zero times (should not print anything)
+-> o100 repeat [0]
+-> (print, fail lit 0)
+-> o100 endrepeat
+-> (print, pass lit 0)
+<- [MSG:INFO: PRINT, pass lit 0]
+
+# test when using a variable
+-> #<count> = 0
+-> o100 repeat [#<count>]
+-> (print, fail var 0)
+-> o100 endrepeat
+-> (print, pass var 0)
+<- [MSG:INFO: PRINT, pass var 0]
+
+# test negative repeat (should not print anything)
+# todo - negative repeat should probably set an error
+-> o100 repeat [-1]
+-> (print, fail lit -1)
+-> o100 endrepeat
+-> (print, pass lit -1)
+<- [MSG:INFO: PRINT, pass lit -1]
+
+# test repeat a fixed number of times
+-> #<count> = 0
+-> o100 repeat [3]
+-> #<count> = [#<count> + 1]
+-> (print, count=%d#<count>)
+<- [MSG:INFO: PRINT, count=1]
+-> o100 endrepeat
+<- [MSG:INFO: PRINT, count=2]
+<- [MSG:INFO: PRINT, count=3]
+
+# test repeating a variable number of times
+-> #<count> = 0
+-> #<i> = 3
+-> o100 repeat [#<i>]
+-> #<count> = [#<count> + 1]
+-> (print, count=%d#<count>)
+<- [MSG:INFO: PRINT, count=1]
+-> o100 endrepeat
+<- [MSG:INFO: PRINT, count=2]
+<- [MSG:INFO: PRINT, count=3]

fixture_tests/run_fixture

@@ -28,6 +28,12 @@ else:
 def run_fixture(fixture_path, controller):
     op_entries_parsed = op_entries.parse_file(fixture_path)
 
+    print(
+        colored(f"--- Run fixture ", "blue")
+        + colored(fixture_path, "blue", attrs=["bold"])
+        + colored(" ---", "blue")
+    )
+
     try:
         for op_entry in op_entries_parsed:
             if not op_entry.execute(controller):
@@ -39,7 +45,8 @@ def run_fixture(fixture_path, controller):
                 exit(1)
 
     except KeyboardInterrupt:
-        print("Interrupt")
+        print("Interrupted by user")
+        exit(1)
 
     except TimeoutError as e:
         print("Timeout waiting for response, line: " + e.args[0])