From 2cf1762569e1d9f3bb4aaca33f8aeadd81cd6be1 Mon Sep 17 00:00:00 2001 From: jonny_ji7 Date: Tue, 20 Sep 2022 09:52:02 +0200 Subject: [PATCH] Optimize auto-cut delay Optimize delay to auto cut by adding a new state AUTO_CUT_WAITING this removes some confusing / unnecessary complex code --- function-diagram.drawio | 2 +- main/control.cpp | 78 +++++++++++++++++++++++------------------ main/control.hpp | 4 +-- 3 files changed, 46 insertions(+), 38 deletions(-) diff --git a/function-diagram.drawio b/function-diagram.drawio index 6062a78..79c9291 100644 --- a/function-diagram.drawio +++ b/function-diagram.drawio @@ -1 +1 @@ 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 \ No newline at end of file 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 \ No newline at end of file diff --git a/main/control.cpp b/main/control.cpp index 74a2a5d..34012df 100644 --- a/main/control.cpp +++ b/main/control.cpp @@ -30,7 +30,7 @@ QueueHandle_t init_encoder(rotary_encoder_info_t * info){ //==================== static const char *TAG = "control"; //tag for logging -const char* systemStateStr[6] = {"COUNTING", "WINDING_START", "WINDING", "TARGET_REACHED", "CUTTING", "MANUAL"}; +const char* systemStateStr[7] = {"COUNTING", "WINDING_START", "WINDING", "TARGET_REACHED", "AUTO_CUT_WAITING", "CUTTING", "MANUAL"}; systemState_t controlState = systemState_t::COUNTING; uint32_t timestamp_changedState = 0; @@ -57,7 +57,6 @@ int cut_msRemaining = 0; uint32_t timestamp_cut_lastBeep = 0; uint32_t autoCut_delayMs = 3000; //TODO add this to config bool autoCutEnabled = false; //store state of toggle switch (no hotswitch) -bool autoCutWaiting = false; //currently waiting (for display) //===== change State ===== @@ -89,9 +88,6 @@ bool handleStopCondition(handledDisplay * displayTop, handledDisplay * displayBo displayTop->blink(1, 0, 1000, " S0LL "); displayBot->blink(1, 0, 1000, "ERREICHT"); buzzer.beep(2, 100, 100); - //store current state once at change to TARGET_REACHED - //(prevent unwanted cut when enabling while already TARGET_REACHED state) - autoCutEnabled = SW_AUTO_CUT.state; return true; } //start button released @@ -226,12 +222,24 @@ void task_control(void *pvParameter) } - //--- beep at AUTO_CUT toggle --- + //--- AUTO_CUT toggle sw --- + //beep at change if (SW_AUTO_CUT.risingEdge){ buzzer.beep(2, 100, 50); } else if (SW_AUTO_CUT.fallingEdge) { buzzer.beep(1, 400, 50); } + //update enabled state + if (SW_AUTO_CUT.state) { + //enable autocut when not in target_reached state + //(prevent immediate/unexpected cut) + if (controlState != systemState_t::TARGET_REACHED){ + autoCutEnabled = true; + } + } else { + //disable anytime (also stops countdown to auto cut) + autoCutEnabled = false; + } //--- manual mode --- @@ -333,10 +341,10 @@ void task_control(void *pvParameter) break; case systemState_t::WINDING: //wind fast, slow down when close - //set vfd speed depending on remaining distance + //set vfd speed depending on remaining distance setDynSpeedLvl(); //slow down when close to target handleStopCondition(&displayTop, &displayBot); //stops if button released or target reached - //TODO: cancel when there is no cable movement anymore e.g. empty / timeout? + //TODO: cancel when there is no cable movement anymore e.g. empty / timeout? break; case systemState_t::TARGET_REACHED: @@ -344,32 +352,11 @@ void task_control(void *pvParameter) //switch to counting state when no longer at or above target length if ( lengthRemaining > 10 ) { //FIXME: require reset switch to be able to restart? or evaluate a tolerance here? changeState(systemState_t::COUNTING); - autoCutWaiting = false; } - //handle delayed cutting if automatic cut is enabled - else if ( (autoCutEnabled == true) + //switch initiate countdown to auto-cut + else if ( (autoCutEnabled) && (esp_log_timestamp() - timestamp_changedState > 300) ){ //wait for dislay msg "reached" to finish - autoCutWaiting = true; //display countdown - cut_msRemaining = autoCut_delayMs - (esp_log_timestamp() - timestamp_changedState); - //- beep countdown - - //time passed since last beep > time remaining / 10 - if ( (esp_log_timestamp() - timestamp_cut_lastBeep) > (cut_msRemaining / 6) - && (esp_log_timestamp() - timestamp_cut_lastBeep) > 50 ){ //dont trigger beeps faster than beep time - buzzer.beep(1, 50, 0); - timestamp_cut_lastBeep = esp_log_timestamp(); - } - //- cancel countdown with AUTO_CUT off - - if (!SW_AUTO_CUT.state) { //note: stop button also works - autoCutWaiting = false; - autoCutEnabled = false; - } - //- trigger cut if delay passed - - else if (cut_msRemaining <= 0){ - cut_msRemaining = 0; //prevent negative number on display - cutter_start(); - changeState(systemState_t::CUTTING); - autoCutWaiting = false; - } + changeState(systemState_t::AUTO_CUT_WAITING); } //show msg when trying to start, but target is reached if (SW_START.risingEdge){ @@ -379,8 +366,29 @@ void task_control(void *pvParameter) } break; + case systemState_t::AUTO_CUT_WAITING: + //handle delayed start of cut + cut_msRemaining = autoCut_delayMs - (esp_log_timestamp() - timestamp_changedState); + //- countdown stop conditions - + if (!autoCutEnabled || !SW_AUTO_CUT.state || SW_RESET.state || SW_CUT.state){ //TODO: also stop when target not reached anymore? + changeState(systemState_t::COUNTING); + } + //- trigger cut if delay passed - + else if (cut_msRemaining <= 0){ + cutter_start(); + changeState(systemState_t::CUTTING); + } + //- beep countdown - + //time passed since last beep > time remaining / 6 + else if ( (esp_log_timestamp() - timestamp_cut_lastBeep) > (cut_msRemaining / 6) + && (esp_log_timestamp() - timestamp_cut_lastBeep) > 50 ){ //dont trigger beeps faster than beep time + buzzer.beep(1, 50, 0); + timestamp_cut_lastBeep = esp_log_timestamp(); + } + break; + case systemState_t::CUTTING: - //exit if finished cutting + //exit when finished cutting if (cutter_isRunning() == false){ //TODO stop if start buttons released? changeState(systemState_t::COUNTING); @@ -453,7 +461,7 @@ void task_control(void *pvParameter) //run handle function displayTop.handle(); //indicate upcoming cut when pending - if (autoCutWaiting == true){ + if (controlState == systemState_t::AUTO_CUT_WAITING){ displayTop.blinkStrings(" CUT 1N ", " ", 70, 30); } //otherwise show current position @@ -485,7 +493,7 @@ void task_control(void *pvParameter) displayBot.blinkStrings("CUTTING]", "CUTTING[", 100, 100); } //show ms countdown to cut when pending - else if (autoCutWaiting == true) { + else if (controlState == systemState_t::AUTO_CUT_WAITING){ sprintf(buf_disp2, " %04d ", cut_msRemaining); //displayBot.showString(buf_disp2); //TODO:blink "erreicht" overrides this. for now using blink as workaround displayBot.blinkStrings(buf_disp2, buf_disp2, 100, 100); diff --git a/main/control.hpp b/main/control.hpp index 6c2c7dc..e70c6ef 100644 --- a/main/control.hpp +++ b/main/control.hpp @@ -26,8 +26,8 @@ extern "C" -enum class systemState_t {COUNTING, WINDING_START, WINDING, TARGET_REACHED, CUTTING, MANUAL}; -extern const char* systemStateStr[6]; +enum class systemState_t {COUNTING, WINDING_START, WINDING, TARGET_REACHED, AUTO_CUT_WAITING, CUTTING, MANUAL}; +extern const char* systemStateStr[7]; void task_control(void *pvParameter);