Store encoder-steps at shutdown, consider at startup

shutdown:
    - add functions to read/write last encoder steps from nvs
    - store encoder steps at shutdown

guide:
    - add function to calculate layer count from cable length
    - read last encoder-steps at startup
    - if length >2m calculate layers, dont home
    - home at move-to-zero when not done at startup

encoder library:
    - add function to set encoder steps

control:
    - read last encoder-steps at startup
    - apply last steps if >2m

components/esp32-rotary-encoder/include/rotary_encoder.h

@@ -164,6 +164,13 @@ esp_err_t rotary_encoder_get_state(const rotary_encoder_info_t * info, rotary_en
  */
 esp_err_t rotary_encoder_reset(rotary_encoder_info_t * info);
 
+/**
+ * @brief Set the current position of the rotary encoder to passed value.
+ * @param[in] info Pointer to initialised rotary encoder info structure.
+ * @return ESP_OK if successful, ESP_FAIL or ESP_ERR_* if an error occurred.
+ */
+esp_err_t rotary_encoder_set_position(rotary_encoder_info_t * info, uint32_t posNew);
+
 
 #ifdef __cplusplus
 }

components/esp32-rotary-encoder/rotary_encoder.c

@@ -343,3 +343,20 @@ esp_err_t rotary_encoder_reset(rotary_encoder_info_t * info)
     }
     return err;
 }
+
+esp_err_t rotary_encoder_set_position(rotary_encoder_info_t * info, uint32_t posNew)
+{
+    esp_err_t err = ESP_OK;
+    if (info)
+    {
+        ESP_LOGI(TAG, "changing rotary encoder position from %d to %d steps", info->state.position, posNew);
+        info->state.position = posNew;
+        info->state.direction = ROTARY_ENCODER_DIRECTION_NOT_SET;
+    }
+    else
+    {
+        ESP_LOGE(TAG, "info is NULL");
+        err = ESP_ERR_INVALID_ARG;
+    }
+    return err;
+}

main/control.cpp

@@ -24,6 +24,7 @@ extern "C"
 #include "guide-stepper.hpp"
 #include "global.hpp"
 #include "control.hpp"
+#include "shutdown.hpp"
 
 
 //-----------------------------------------
@@ -157,6 +158,15 @@ void task_control(void *pvParameter)
     //currently show name and date and scrolling 'hello'
     display_ShowWelcomeMsg(two7SegDisplays);
 
+    //-- consider previous length from nvs -- 
+    //read stored length from last shutdown
+    int encoderPosLastShutdown = nvsReadLastEncoderSteps();
+    // apply stored length when significant
+    if (encoderPosLastShutdown > 2*ENCODER_STEPS_PER_METER){
+        encoder_setPos(encoderPosLastShutdown);
+        ESP_LOGW(TAG, "set encoder to last known steps %d (from last shutdown)", encoderPosLastShutdown);
+    }
+
     // ##############################
     // ######## control loop ########
     // ##############################

main/encoder.cpp

@@ -77,3 +77,12 @@ void encoder_reset(){
     rotary_encoder_reset(&encoder);
     return;
 }    
+
+//========================
+//==== encoder_setPos ====
+//========================
+//set encoder position to certain Steps
+void encoder_setPos(uint32_t posNew){
+    rotary_encoder_set_position(&encoder, posNew);
+    return;
+}

main/encoder.hpp

@@ -4,6 +4,7 @@
 #pragma once
 extern "C" {
 #include <freertos/task.h>
+#include "freertos/queue.h"
 }
 
 
@@ -36,3 +37,7 @@ int encoder_getLenMm();
 //--- encoder_reset ---
 //reset counted steps / length to 0
 void encoder_reset();
+
+//--- encoder_setPos ---
+//set encoder position to certain Steps
+void encoder_setPos(uint32_t posNew);

main/guide-stepper.cpp

@@ -64,6 +64,11 @@ static uint32_t posNow = 0;
 
 static int layerCount = 0;
 
+// store optimal distance traveled when homing (determined by last pos in nvs)
+static int homeTravelDistance = MAX_TOTAL_AXIS_TRAVEL_MM;
+// track if already homed (either homes at startup or at first reset when there is still cable on the reel)
+static bool axisIsHomed = false;
+
 // queue for sending commands to task handling guide movement
 static QueueHandle_t queue_commandsGuideTask;
 
@@ -87,7 +92,13 @@ int guide_getAxisPosSteps(){
 //==========================
 //tell stepper-control task to move cable guide to zero position
 void guide_moveToZero(){
-    bool valueToSend = true; // or false
+    //home axis first if not done already at startup
+    if (!axisIsHomed){
+        ESP_LOGW(TAG, "moveToZero: Axis not homed yet due to high previous length -> homing now");
+        stepper_home(homeTravelDistance);
+        axisIsHomed = true;
+    }
+    bool valueToSend = true; // or false - currently not relevant
     xQueueSend(queue_commandsGuideTask, &valueToSend, portMAX_DELAY);
     ESP_LOGI(TAG, "sending command to stepper_ctl task via queue");
 }
@@ -100,7 +111,7 @@ void guide_moveToZero(){
 void travelSteps(int stepsTarget){
 	//TODO simplify this function, one simple calculation of new position?
 	//with new custom driver no need to detect direction change
-	
+
     int stepsToGo, remaining;
 
     stepsToGo = abs(stepsTarget);
@@ -165,6 +176,32 @@ void travelSteps(int stepsTarget){
 }
 
 
+//------------------------
+//---- lengthToLayers ----
+//------------------------
+// calculate cable layers on reel from a certain cable length
+// TODO: currently assumes windingWidth is constant (MAX_MM)
+uint16_t lengthToLayers(float lengthMm){
+    float windingWidth = MAX_MM;
+    uint16_t layerCount = 0;
+    //cable length required for one layer
+    float lenNextLayer = (PI * D_REEL) * (windingWidth / D_CABLE);
+    uint32_t lengthRemaining = lengthMm;
+
+    while (lengthRemaining >= lenNextLayer){
+        float lenThisLayer = lenNextLayer; 
+        lengthRemaining -= lenThisLayer;
+        layerCount++;
+
+        float currentDiameter = D_REEL + LAYER_THICKNESS_MM * 2 * layerCount;
+        lenNextLayer = (PI * currentDiameter) * windingWidth/D_CABLE;
+    }
+
+    ESP_LOGI(TAG, "lengthToLayers: calculated %d layers from length=%.1fm, windWidth=%.1fmm, D-cable=%dmm, D-start=%dmm", layerCount, lengthMm/1000, windingWidth, D_CABLE, D_REEL);
+    return layerCount;
+}
+
+
 //------------------
 //---- travelMm ----
 //------------------
@@ -302,9 +339,10 @@ void task_stepper_ctl(void *pvParameter)
 
 
 
-    //initialize stepper at task start
+    //-- initialize stepper --
     init_stepper();
-    //define zero-position
+
+    //-- consider axis-position at last shutdown --
     // use last known position stored at last shutdown to reduce time crashing into hardware limit
     int posLastShutdown = nvsReadLastAxisPosSteps();
     if (posLastShutdown >= 0)
@@ -313,10 +351,24 @@ void task_stepper_ctl(void *pvParameter)
         posLastShutdown / STEPPER_STEPS_PER_MM, 
         AUTO_HOME_TRAVEL_ADD_TO_LAST_POS_MM);
         // home considering last position and offset, but limit to max distance possible
-        stepper_home(MIN((posLastShutdown/STEPPER_STEPS_PER_MM + AUTO_HOME_TRAVEL_ADD_TO_LAST_POS_MM), MAX_TOTAL_AXIS_TRAVEL_MM));
+         homeTravelDistance = MIN((posLastShutdown/STEPPER_STEPS_PER_MM + AUTO_HOME_TRAVEL_ADD_TO_LAST_POS_MM), MAX_TOTAL_AXIS_TRAVEL_MM);
     }
     else { // default to max travel when read from nvs failed
         stepper_home(MAX_TOTAL_AXIS_TRAVEL_MM);
+        homeTravelDistance = MAX_TOTAL_AXIS_TRAVEL_MM; //note: is default value anyways
+    }
+
+    //-- consider measured length at last shutdown --
+    //read length at last power-off
+    int encoderPosLastShutdown = nvsReadLastEncoderSteps();
+    // when significant length stored: calculate layer count, dont home stepper yet (only at next RESET button press)
+    if (encoderPosLastShutdown > 2*ENCODER_STEPS_PER_METER){
+        layerCount = lengthToLayers((float)encoderPosLastShutdown/ENCODER_STEPS_PER_METER * 1000);
+        ESP_LOGW(TAG, "last stored length is %.1fm -> set layer count to %d", (float)encoderPosLastShutdown/ENCODER_STEPS_PER_METER, layerCount);
+    }
+    else { //last stored length is not significant: home stepper
+        stepper_home(homeTravelDistance);
+        axisIsHomed = true;
     }
 
     //repeatedly read changes in measured cable length and move axis accordingly

main/shutdown.cpp

@@ -11,6 +11,7 @@ extern "C"
 }
 
 #include "config.h"
+#include "encoder.hpp"
 #include "shutdown.hpp"
 
 #include "guide-stepper.hpp"
@@ -34,10 +35,28 @@ void nvsWriteLastAxisPos(uint32_t value)
         ESP_LOGE(TAG, "nvs: failed committing updates");
     else
         ESP_LOGI(TAG, "nvs: successfully committed updates");
-    ESP_LOGW(TAG, "updated value in nvs to %d", value);
+    ESP_LOGW(TAG, "updated value 'lastPosSteps' in nvs to %d", value);
 }
 
 
+// store a u32 value in nvs as "lastEncoderSteps"
+// TODO remove duplicate code
+void nvsWriteLastEncoderSteps(uint32_t value)
+{
+    // update nvs value
+    esp_err_t err = nvs_set_u32(nvsHandle, "lastEncoderSteps", value);
+    if (err != ESP_OK)
+        ESP_LOGE(TAG, "nvs: failed writing");
+    err = nvs_commit(nvsHandle);
+    if (err != ESP_OK)
+        ESP_LOGE(TAG, "nvs: failed committing updates");
+    else
+        ESP_LOGI(TAG, "nvs: successfully committed updates");
+    ESP_LOGW(TAG, "updated value 'lastEncoderSteps' in nvs to %d", value);
+}
+
+
+
 
 // read "lastPosSteps" from nvs, returns -1 if failed
 int nvsReadLastAxisPosSteps()
@@ -61,6 +80,29 @@ int nvsReadLastAxisPosSteps()
 }
 
 
+// read "lastEncoderSteps" from nvs, returns -1 if failed
+// TODO remove duplicate code
+int nvsReadLastEncoderSteps()
+{
+    uint32_t valueRead;
+    esp_err_t err = nvs_get_u32(nvsHandle, "lastEncoderSteps", &valueRead);
+    switch (err)
+    {
+    case ESP_OK:
+        ESP_LOGW(TAG, "Successfully read value %d from nvs", valueRead);
+        return valueRead;
+        break;
+    case ESP_ERR_NVS_NOT_FOUND:
+        ESP_LOGE(TAG, "nvs: the value '%s' is not initialized yet", "lastEncoderSteps");
+        return -1;
+        break;
+    default:
+        ESP_LOGE(TAG, "Error (%s) reading nvs!", esp_err_to_name(err));
+        return -1;
+    }
+}
+
+
 
 // task that repeatedly checks supply voltage (12V) and saves certain values to nvs in case of power off detected
 // note: with the 2200uF capacitor in the 12V supply and measuring if 12V start do drop here, there is more than enough time to take action until the 3v3 regulator turns off
@@ -101,7 +143,8 @@ void task_shutDownDetection(void *pvParameter)
             // write to nvs and log once at change to below
             if (!voltageBelowThreshold){
                 nvsWriteLastAxisPos(guide_getAxisPosSteps());
-                ESP_LOGE(TAG, "voltage now below threshold!  now=%d threshold=%d -> wrote last axis-pos to nvs", adc_reading, ADC_LOW_VOLTAGE_THRESHOLD);
+                nvsWriteLastEncoderSteps(encoder_getSteps());
+                ESP_LOGE(TAG, "voltage now below threshold!  now=%d threshold=%d -> wrote last axis-pos and encoder-steps to nvs", adc_reading, ADC_LOW_VOLTAGE_THRESHOLD);
                 voltageBelowThreshold = true;
             }
         }

main/shutdown.hpp

@@ -4,4 +4,7 @@ void task_shutDownDetection(void *pvParameter);
 
 // read last axis position in steps from nvs
 // returns -1 when reading from nvs failed
-int nvsReadLastAxisPosSteps();
+int nvsReadLastAxisPosSteps();
+
+// read last encoder steps from nvs
+int nvsReadLastEncoderSteps();