Updated state scheduler

main/src/config/all_config.h

@@ -6,6 +6,7 @@
 #include "timing_config.h"
 #include "layout_config.h"
 #include "hw_config.h"
+#include "nbus_config.h"
 #include "icons/all_icons.h"
 
 

main/src/config/colors_config.h

@@ -1,6 +1,9 @@
 #ifndef _COLORS_CONFIG_H_
 #define _COLORS_CONFIG_H_
 
+#define COL_BG                TFT_BLACK
+#define COL_TEXT_FG           TFT_WHITE
+
 #define COL_ICON_FG           TFT_WHITE
 
 #define COL_ICON_BG_INACTIVE  TFT_GREY
@@ -8,5 +11,4 @@
 #define COL_ICON_BG_CANCEL    TFT_RED
 #define COL_ICON_BG_REC       TFT_RED
 
-
 #endif // _COLORS_H_

main/src/config/hw_config.h

@@ -3,6 +3,10 @@
 
 #define SERIAL_BAUD 115200
 
+#define CORE_LOW_POWER_FREQUENCY_MHZ    10
+
+#define DISP_BRIGHTNESS 16
+
 #define EN_SERIAL_CHANNEL 11
 #define EN_SERIAL_BROADCAST false
 #define EN_SERIAL_ADDRESS {0x9c, 0x9e, 0x6e, 0xe0, 0x87, 0xf4}

main/src/config/nbus_config.h

@@ -0,0 +1,12 @@
+#ifndef _NBUS_CONFIG_H_
+#define _NBUS_CONFIG_H_
+
+#define NBUS_MEAS_ID            6
+#define NBUS_PHASE_TARGET       1
+#define NBUS_PHASE_INTERLUDE    2
+#define NBUS_PHASE_START        3
+#define NBUS_PHASE_MOVEMENT     4
+#define NBUS_PHASE_STOP         5
+#define NBUS_PHASE_ACK          6
+
+#endif // _NBUS_CONFIG_H_

main/src/config/states_config.h

@@ -3,9 +3,7 @@
 
 enum StateID
 {
-    STATE_NULL = -1,
     STATE_LOCK = 0,
-    STATE_UNLOCK,
     STATE_TARGET,
     STATE_START,
     STATE_RUN,

main/src/data_structures/phase_cmd.h

@@ -15,4 +15,5 @@ union PhaseCmd
     uint8_t data[3];
 };
 
+
 #endif // _PHASE_CMD_H_

main/src/data_structures/state_tx.h

@@ -3,15 +3,23 @@
 
 #include <cinttypes>
 
-enum StateID;
+enum StateID;       ///< Forward-declared type
 
-struct StateTx
+enum StateTxMode
 {
-    StateTx(StateID id) : id{id}, wait{-1} {}
-    StateTx(StateID id, int64_t wait) : id{id}, wait{wait} {}
+    NO_OP,
+    REFRESH,
+    WAIT,
+    REFRESH_WAIT,
+    ERROR
+};
 
+struct StateTx
+{
     StateID id;
-    int64_t wait;
+    StateTxMode mode{NO_OP};
+    uint64_t wait{0};
 };
 
+
 #endif // _STATE_DATA_H_

main/src/device/device.cpp

@@ -19,8 +19,6 @@ void Device::set_battery_refresh(bool value)
 void Device::begin_esp_now_serial()
 {
     EnSerial.begin(EN_SERIAL_CHANNEL, EN_SERIAL_BROADCAST);
-    EspMacAddress rx_address = EN_SERIAL_ADDRESS;    
-    EnSerial.add_peer(rx_address);
     _wifi_active = true;
 }
 
@@ -37,10 +35,13 @@ bool Device::hardware_init()
     Serial.begin(SERIAL_BAUD);
     
     // init M5 base class
-    this->M5Board.begin();
+    M5Board.begin();
 
-    // init esp-now serial
-    this->begin_esp_now_serial();
+    // add esp-now serial peer
+    EnSerial.begin(EN_SERIAL_CHANNEL, EN_SERIAL_BROADCAST);
+    EspMacAddress rx_address = EN_SERIAL_ADDRESS;    
+    EnSerial.add_peer(rx_address);
+    EnSerial.end();
 
     // init drawer
     Drawer.begin();
@@ -58,12 +59,12 @@ void Device::enter_low_power()
     if (_wifi_active)
         end_esp_now_serial();
 
-    setCpuFrequencyMhz(10);
+    setCpuFrequencyMhz(CORE_LOW_POWER_FREQUENCY_MHZ);
 }
 
 void Device::enter_high_power(bool wifi)
 {
-    setCpuFrequencyMhz(160);
+    setCpuFrequencyMhz(CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ);
     
     if (wifi)
         begin_esp_now_serial();

main/src/drawer/drawer.cpp

@@ -16,7 +16,7 @@ void M5Drawer::begin()
 }
 
 void M5Drawer::refresh()
-{
+{    
     _sprite.pushSprite(0, 0);
 
 }
@@ -49,8 +49,7 @@ void M5Drawer::draw_description(const char* line1, const char* line2, int16_t y_
     int16_t text_max_height = _sprite.fontHeight() * 2;
     _sprite.fillRect(0, _center_y + y_offset, _display.width(), text_max_height, _color_bg_text);
 
-    int16_t half_max_width = max(_sprite.textWidth(line1), _sprite.textWidth(line2)) / 2;
-    int16_t x0 = _center_x;// - half_max_width;
+    int16_t x0 = _center_x;
     int16_t y0 = _center_y + y_offset;
 
     _sprite.setTextDatum(top_center);
@@ -63,19 +62,26 @@ void M5Drawer::draw_description(const char* line1, const char* line2, int16_t y_
 void M5Drawer::draw_battery(int32_t level)
 {
     _sprite.setFont(&Font4);
+    _sprite.setTextDatum(top_right);
+
+    _sprite.setTextColor(COL_BG, COL_BG);
+     _sprite.drawString("000%", _display.width() - 1, 0);
+
 
+    _sprite.setTextColor(COL_TEXT_FG, COL_BG);
     snprintf(_string_buff, sizeof(_string_buff), "%d%%", (int16_t)level);
-    
-    _sprite.setTextDatum(top_right);
     _sprite.drawString(_string_buff, _display.width() - 1, 0);
 }
 
 void M5Drawer::draw_measure_number(int16_t number)
 {
     _sprite.setFont(&Font4);
+    _sprite.setTextDatum(top_left);
 
+    _sprite.setTextColor(COL_BG, COL_BG);
+    _sprite.drawString("M000", 0, 0);
+
+    _sprite.setTextColor(COL_TEXT_FG, COL_BG);
     snprintf(_string_buff, sizeof(_string_buff), "M%d", number);
-    
-    _sprite.setTextDatum(top_left);
     _sprite.drawString(_string_buff, 0, 0);
 }

main/src/drawer/drawer.h

@@ -3,6 +3,7 @@
 
 #include <M5GFX.h>
 #include "data_structures/icon_struct.h"
+#include "all_config.h"
 
 class M5Drawer
 {

main/src/main.cpp

@@ -9,7 +9,6 @@
 NbusComm NBC(Dev.EnSerial);
 
 StateLock   state_lock;
-StateUnlock state_unlock;
 StateTarget state_target;
 StateStart  state_start;
 StateRun    state_run;
@@ -18,7 +17,6 @@ StateCancel state_cancel;
 
 IState *states[_STATES_COUNT] = {
   &state_lock,
-  &state_unlock,
   &state_target,
   &state_start,
   &state_run,
@@ -34,63 +32,112 @@ void setup()
 {
 
   Dev.hardware_init();
-  Dev.M5Board.Display.setBrightness(16);
+  Dev.M5Board.Display.setBrightness(DISP_BRIGHTNESS);
 
   Dev.Drawer.set_text_color(TFT_WHITE, TFT_BLACK);
   Dev.Drawer.draw_battery(Dev.M5Board.Power.getBatteryLevel());
 
   time0 = Dev.M5Board.millis();
   
-  states[curr_state.id]->setup();
+  states[curr_state.id]->begin();
   Dev.Drawer.refresh();
-
- // Dev.M5Board.delay(1000);
- // uint8_t aa[] = {6, 1, 3};
- // NBC.cmd_set_data(aa, 3); 
-
-
-
+  Dev.enter_low_power();
 }
 
-void loop()
+void _update_loop()
 {
+  curr_state = next_state;
+  Dev.M5Board.update();
+}
 
+void _handle_same_state()
+{
+  if (next_state.mode != 0)
+  Serial.println((int)next_state.mode);
 
-  // 1. Spracovanie stavov (teraz už má čerstvé dáta z tlačidiel)
-  next_state = states[curr_state.id]->loop(Dev.M5Board.millis() - time0);
-
-  // pause transition if needed
-  if (next_state.wait >= 0)
+  if (next_state.mode == REFRESH || next_state.mode == REFRESH_WAIT)
   {
+    // upadte screen
     Dev.enter_high_power(false);
     Dev.Drawer.refresh();
+    Serial.println("here");
     Dev.enter_low_power();
-    
-    if (next_state.wait > 0)
-      Dev.M5Board.delay(next_state.wait);
   }
 
-  // 2. Prechod do nového stavu, ak nastala zmena
-  if (next_state.id != curr_state.id)
+  if (next_state.mode == WAIT || next_state.mode == REFRESH_WAIT)
+  {
+    Dev.M5Board.delay(next_state.wait);
+  }
+}
+
+void _handle_next_state()
+{
+  // if error occured
+  if (next_state.mode == ERROR)
+  {
+    Dev.enter_high_power(false);              // do not turn on wifi in error, do not call end()
+  }
+  else
+  {
+    Dev.enter_high_power(true);               // turn on wifi 
+    states[curr_state.id]->end();             // properly end previous state
+  }
+
+  // refresh display if needed
+  if (next_state.mode == REFRESH || next_state.mode == REFRESH_WAIT)
   {
-    time0 = millis();
-    curr_state = next_state;
-    Dev.enter_high_power(true);
-    Serial.println(getCpuFrequencyMhz());
-    states[curr_state.id]->setup();
     Dev.Drawer.refresh();
-    Dev.enter_low_power();
-    Serial.println(getCpuFrequencyMhz());
+  }
 
+  // wait between states if needed
+  if (next_state.mode == WAIT || next_state.mode == REFRESH_WAIT)
+  {    
+    Dev.enter_low_power();                    // go to low power mode
+    Dev.M5Board.delay(next_state.wait);       // during wait
+    Dev.enter_high_power(true);
   }
 
-  // 3. Obnovenie batérie, ak je vyžiadané
-  if (Dev.get_battery_refresh())
+  // init new state
+  states[next_state.id]->begin();
+  Dev.Drawer.refresh();
+
+  // go to low power
+  Dev.enter_low_power();
+  // set new time
+  time0 = Dev.M5Board.millis();
+}
+
+void _update_battery()
+{
+  // redraw battery
+  Dev.set_battery_refresh(false);
+  Dev.Drawer.draw_battery(Dev.M5Board.Power.getBatteryLevel());
+
+  // upadte screen
+  Dev.enter_high_power(false);
+  Dev.Drawer.refresh();
+  Dev.enter_low_power();
+}
+
+void loop()
+{
+  // proces logic on loop
+  next_state = states[curr_state.id]->loop(Dev.M5Board.millis() - time0);
+  if (next_state.mode != 0)
   {
-    Dev.set_battery_refresh(false);
-    Dev.Drawer.draw_battery(Dev.M5Board.Power.getBatteryLevel());
+    Serial.printf("state %d -> %d", next_state.id, next_state.mode);
   }
+  
+  // if no state change
+  if (next_state.id == curr_state.id)
+    _handle_same_state();
+  else
+    _handle_next_state();
 
-    // 0. AKTUALIZÁCIA HARDVÉRU MUSÍ BYŤ PRVÁ (hlavne po prebudení zo spánku!)
-  Dev.M5Board.update();
+  // update battery
+  if (Dev.get_battery_refresh())
+    _update_battery();
+
+  // update current variables
+  _update_loop();
 }

main/src/states/state_impl/state_impl.cpp

@@ -1,23 +1,53 @@
 #include "state_impl.h"
 
+//////////////////////////////////////////////////////////////////////////////////////////////////
+//  GENERIC STATE
+//////////////////////////////////////////////////////////////////////////////////////////////////
+    
+void GenericState::send_start()
+{
+    GenericState::_nbus_comm.cmd_set_start();
+}
+
+void GenericState::send_phase(int8_t phase)
+{
+    GenericState::_nbus_comm.cmd_set_data(PhaseCmd{NBUS_MEAS_ID, (uint8_t)GenericState::_measure_num, (uint8_t)phase}.data, sizeof(PhaseCmd));
+}
+
+void GenericState::send_stop()
+{
+    GenericState::_nbus_comm.cmd_set_stop();
+}
+
 
 //////////////////////////////////////////////////////////////////////////////////////////////////
 //  STATE LOCK
 //////////////////////////////////////////////////////////////////////////////////////////////////
 
-void StateLock::setup()
+void StateLock::begin()
 {
+    GenericState::send_stop();
+    
     // draw screen
     Dev.Drawer.draw_icon(LOCK_ICON, COL_ICON_FG, COL_ICON_BG_INACTIVE, LAY_ICON_YOFFSET);
     Dev.Drawer.draw_description("Odomknite", "podrzanim", LAY_DESC_YOFFSET);
-    Dev.Drawer.draw_measure_number(GenericState::measure_num++);
+    Dev.Drawer.draw_measure_number(GenericState::_measure_num++);
 }
 
 StateTx StateLock::loop(int64_t duration)
 {
-    // long press -> unlock
-    if (Dev.M5Board.BtnB.pressedFor(TIM_LONG_PRESS))
-        return {STATE_UNLOCK};
+    // long press -> enter unlock mode
+    if (Dev.M5Board.BtnA.pressedFor(TIM_LONG_PRESS))
+    {
+        // draw unlock screen
+        Dev.Drawer.draw_icon(UNLOCK_ICON, COL_ICON_FG, COL_ICON_BG_ACTIVE, LAY_ICON_YOFFSET);
+        Dev.Drawer.draw_description("Ovladac", "odomknuty", LAY_DESC_YOFFSET);
+        return {STATE_LOCK, REFRESH_WAIT, TIM_INFO_SCREEN};
+    }
+
+    // released button -> go to target
+    else if (Dev.M5Board.BtnA.wasReleased())
+       return {STATE_TARGET};
 
     // timer -> power off    
     if (duration > TIM_POWER_OFF)
@@ -26,25 +56,9 @@ StateTx StateLock::loop(int64_t duration)
     return {STATE_LOCK};
 }
 
-
-//////////////////////////////////////////////////////////////////////////////////////////////////
-//  STATE UNLOCK
-//////////////////////////////////////////////////////////////////////////////////////////////////
-
-void StateUnlock::setup()
-{
-    // draw screen
-    Dev.Drawer.draw_icon(UNLOCK_ICON, COL_ICON_FG, COL_ICON_BG_ACTIVE, LAY_ICON_YOFFSET);
-    Dev.Drawer.draw_description("Odomknute", "", LAY_DESC_YOFFSET);
-}
-
-StateTx StateUnlock::loop(int64_t duration)
+void StateLock::end()
 {
-    // wait until button is released
-    if (Dev.M5Board.BtnA.isReleased())
-       return {STATE_TARGET, TIM_INFO_SCREEN};
-
-    return {STATE_UNLOCK};
+    return;
 }
 
 
@@ -52,7 +66,7 @@ StateTx StateUnlock::loop(int64_t duration)
 //  STATE TARGET
 //////////////////////////////////////////////////////////////////////////////////////////////////
 
-void StateTarget::setup()
+void StateTarget::begin()
 {
     // draw screen
     Dev.Drawer.draw_icon(TARGET_ICON, COL_ICON_FG, COL_ICON_BG_INACTIVE, LAY_ICON_YOFFSET);
@@ -63,26 +77,34 @@ StateTx StateTarget::loop(int64_t duration)
 {
     // long press -> cancel
     if (Dev.M5Board.BtnA.pressedFor(TIM_LONG_PRESS))
-        return {STATE_CANCEL};
+       return {STATE_CANCEL, ERROR};
 
     
     // short press -> start
     if (Dev.M5Board.BtnA.wasReleased())
-    {
-        Dev.Drawer.draw_icon(TARGET_ICON, COL_ICON_FG, COL_ICON_BG_ACTIVE, LAY_ICON_YOFFSET);
-        return {STATE_START, TIM_INFO_SCREEN};
-    }
+        return {STATE_START, REFRESH_WAIT, TIM_INFO_SCREEN};
 
     return {STATE_TARGET};
 }
 
+void StateTarget::end()
+{
+    GenericState::send_start();
+    GenericState::send_phase(NBUS_PHASE_TARGET);
+
+    Dev.Drawer.draw_icon(TARGET_ICON, COL_ICON_FG, COL_ICON_BG_ACTIVE, LAY_ICON_YOFFSET);
+}
+
 
 //////////////////////////////////////////////////////////////////////////////////////////////////
 //  STATE START
 //////////////////////////////////////////////////////////////////////////////////////////////////
 
-void StateStart::setup()
+void StateStart::begin()
 {
+    // set measuring phase
+    GenericState::send_phase(NBUS_PHASE_INTERLUDE);
+    
     // draw screen
     Dev.Drawer.draw_icon(GO_ICON, COL_ICON_FG, COL_ICON_BG_INACTIVE, LAY_ICON_YOFFSET);
     Dev.Drawer.draw_description("Spustite", "meranie", LAY_DESC_YOFFSET);
@@ -92,23 +114,27 @@ StateTx StateStart::loop(int64_t duration)
 {
     // long press -> cancel
     if (Dev.M5Board.BtnA.pressedFor(TIM_LONG_PRESS))
-        return {STATE_CANCEL};
+        return {STATE_CANCEL, ERROR};
 
     // short press -> run
     if (Dev.M5Board.BtnA.wasReleased())
-    {
-        Dev.Drawer.draw_icon(GO_ICON, COL_ICON_FG, COL_ICON_BG_ACTIVE, LAY_ICON_YOFFSET);
-        return {STATE_RUN, TIM_INFO_SCREEN};
-    }
-    
+        return {STATE_RUN, REFRESH_WAIT, TIM_INFO_SCREEN};
+
     return {STATE_START};
 }
 
+void StateStart::end()
+{
+    GenericState::send_phase(NBUS_PHASE_START);
+
+    Dev.Drawer.draw_icon(GO_ICON, COL_ICON_FG, COL_ICON_BG_ACTIVE, LAY_ICON_YOFFSET);
+}
+
 //////////////////////////////////////////////////////////////////////////////////////////////////
 //  STATE RUN
 //////////////////////////////////////////////////////////////////////////////////////////////////
 
-void StateRun::setup()
+void StateRun::begin()
 {
     // draw screen
     Dev.Drawer.draw_icon(REC_ICON, COL_ICON_FG, COL_ICON_BG_INACTIVE, LAY_ICON_YOFFSET);
@@ -119,7 +145,7 @@ StateTx StateRun::loop(int64_t duration)
 {
     // long press -> cancel
     if (Dev.M5Board.BtnA.pressedFor(TIM_LONG_PRESS))
-        return {STATE_CANCEL};
+        return {STATE_CANCEL, ERROR};
 
     // if need to refresh
     if (duration - _last_blink_time >= TIM_RUN_BLINK)
@@ -130,32 +156,40 @@ StateTx StateRun::loop(int64_t duration)
         if (_icon_state)
         {
             Dev.Drawer.draw_icon(REC_ICON, COL_ICON_FG, COL_ICON_BG_REC, LAY_ICON_YOFFSET);
-            return {STATE_RUN, TIM_RUN_REFRESH};
+            return {STATE_RUN, REFRESH};
         }
         else
         {
+        
             Dev.Drawer.draw_icon(REC_ICON, COL_ICON_FG, COL_ICON_BG_INACTIVE, LAY_ICON_YOFFSET);
-            return {STATE_RUN, TIM_RUN_REFRESH};
+            return {STATE_RUN, REFRESH};
         }
     }
 
     // short press -> stop
     if (Dev.M5Board.BtnA.wasReleased())
-    {
-        _last_blink_time = 0;
-        _icon_state = false;
-        return {STATE_STOP};
-    }
+        return {STATE_STOP, REFRESH};
 
     return {STATE_RUN};
 }
 
+void StateRun::end()
+{
+    _last_blink_time = 0;
+    _icon_state = false;
+    GenericState::send_phase(NBUS_PHASE_MOVEMENT);
+}
+
 //////////////////////////////////////////////////////////////////////////////////////////////////
 //  STATE STOP
 //////////////////////////////////////////////////////////////////////////////////////////////////
 
-void StateStop::setup()
+
+
+void StateStop::begin()
 {
+    GenericState::send_phase(NBUS_PHASE_ACK);
+
     // draw screen
     Dev.Drawer.draw_icon(OK_ICON, COL_ICON_FG, COL_ICON_BG_INACTIVE, LAY_ICON_YOFFSET);
     Dev.Drawer.draw_description("Meranie", "dokoncene", LAY_DESC_YOFFSET);
@@ -164,22 +198,24 @@ void StateStop::setup()
 StateTx StateStop::loop(int64_t duration)
 {
     if (duration > TIM_INFO_SCREEN)
-    {
-        Dev.Drawer.draw_icon(OK_ICON, COL_ICON_FG, COL_ICON_BG_ACTIVE, LAY_ICON_YOFFSET);
-        return {STATE_LOCK, TIM_INFO_SCREEN};
-    }
+        return {STATE_LOCK, REFRESH_WAIT, TIM_INFO_SCREEN};
 
     return {STATE_STOP};
 }
 
+void StateStop::end()
+{
+    Dev.Drawer.draw_icon(OK_ICON, COL_ICON_FG, COL_ICON_BG_ACTIVE, LAY_ICON_YOFFSET);
+}
+
 
 //////////////////////////////////////////////////////////////////////////////////////////////////
 //  STATE CANCEL
 //////////////////////////////////////////////////////////////////////////////////////////////////
 
-void StateCancel::setup()
+void StateCancel::begin()
 {
-    Dev.Drawer.draw_measure_number(--GenericState::measure_num);
+    Dev.Drawer.draw_measure_number(--GenericState::_measure_num);
     Dev.Drawer.draw_icon(CANCEL_ICON, COL_ICON_FG, COL_ICON_BG_CANCEL, LAY_ICON_YOFFSET);
     Dev.Drawer.draw_description("Meranie", "zrusene", LAY_DESC_YOFFSET);
 }
@@ -190,4 +226,9 @@ StateTx StateCancel::loop(int64_t duration)
         return {STATE_LOCK};
     
     return {STATE_CANCEL};
+}
+
+void StateCancel::end()
+{
+    return;
 }

main/src/states/state_impl/state_impl.h

@@ -3,54 +3,57 @@
 
 #include "device/device.h"
 #include "states/state_interface.h"
+#include "nbus/nbus_comm.h"
+#include "data_structures/phase_cmd.h"
 
 #include <atomic>
 
 
 class GenericState: public IState
 {
-public:
-    inline static std::atomic<int32_t> measure_num{1};
-};
+protected:
+    static void send_start();
+    static void send_phase(int8_t phase);
+    static void send_stop();
 
-
-class StateLock : public GenericState
-{
-public:
-    void setup() override;
-    StateTx loop(int64_t duration) override;
+    inline static std::atomic<int32_t> _measure_num{1};
+    inline static NbusComm _nbus_comm{Dev.EnSerial};
 };
 
 
-class StateUnlock : public GenericState
+class StateLock : public GenericState
 {
 public:
-    void setup() override;
+    void begin() override;
     StateTx loop(int64_t duration) override;
+    void end() override;
 };
 
 
 class StateTarget : public GenericState
 {
 public:
-    void setup() override;
+    void begin() override;
     StateTx loop(int64_t duration) override;
+    void end() override;
 };
 
 
 class StateStart : public GenericState
 {
 public:
-    void setup() override;
+    void begin() override;
     StateTx loop(int64_t duration) override;
+    void end() override;
 };
 
 
 class StateRun : public GenericState
 {
 public:
-    void setup() override;
+    void begin() override;
     StateTx loop(int64_t duration) override;
+    void end() override;
 private:
     int64_t _last_blink_time = 0;
     bool _icon_state = false;
@@ -59,16 +62,18 @@ private:
 class StateStop : public GenericState
 {
 public:
-    void setup() override;
+    void begin() override;
     StateTx loop(int64_t duration) override;
+    void end() override;
 };
 
 
 class StateCancel : public GenericState
 {
 public:
-    void setup() override;
+    void begin() override;
     StateTx loop(int64_t duration) override;
+    void end() override;
 };
 
 

main/src/states/state_interface.h

@@ -7,8 +7,9 @@
 class IState
 {
 public:
-    virtual void setup() = 0;
+    virtual void begin() = 0;
     virtual StateTx loop(int64_t duration) = 0; 
+    virtual void end() = 0;
 };