Merge branch 'nvs' into dev - restore last pos works

Last position gets stored at shutdown, loaded at startup and used
to optimize initial auto-home.

main/CMakeLists.txt

@@ -11,6 +11,7 @@ idf_component_register(
 		"stepper.cpp"
         "guide-stepper.cpp"
         "encoder.cpp"
+        "shutdown.cpp"
     INCLUDE_DIRS 
         "."
     )

main/config.h

@@ -27,6 +27,12 @@
 #define ADC_CHANNEL_POTI ADC1_CHANNEL_0
 #define GPIO_4SW_TO_ANALOG GPIO_NUM_39
 #define ADC_CHANNEL_4SW_TO_ANALOG ADC1_CHANNEL_3 //gpio 39
+
+#define ADC_CHANNEL ADC_CHANNEL_0
+//#define ADC_LOW_VOLTAGE_THRESHOLD 1000 //adc value where shut down is detected (store certain values before power loss)
+#define GPIO_PIN GPIO_NUM_2
+
+#define ADC_CHANNEL_SUPPLY_VOLTAGE ADC1_CHANNEL_7//gpio35 onboard supply voltage
 //ADC1_CHANNEL_0 gpio36
 //ADC1_CHANNEL_6 gpio_34
 //ADC1_CHANNEL_3 gpio_39
@@ -87,8 +93,8 @@
 #define STEPPER_STEP_PIN		GPIO_NUM_18    //mos1
 #define STEPPER_DIR_PIN			GPIO_NUM_16     //ST3
 //driver settings
-#define STEPPER_STEPS_PER_MM	200/2	//steps/mm (steps-per-rot / spindle-slope)
+#define STEPPER_STEPS_PER_MM	(200/2)	//steps/mm (steps-per-rot / spindle-slope)
-#define STEPPER_SPEED_DEFAULT	20		//mm/s
+#define STEPPER_SPEED_DEFAULT	25		//mm/s
 #define STEPPER_SPEED_MIN		4		//mm/s  - speed threshold at which stepper immediately starts/stops
 #define STEPPER_ACCEL_INC		3		//steps/s increment per cycle 
 #define STEPPER_DECEL_INC		7		//steps/s decrement per cycle
@@ -102,16 +108,18 @@
 //enable mode  encoder test for calibration (determine ENCODER_STEPS_PER_METER)
 //if defined, displays always show length and steps instead of the normal messages
 //#define ENCODER_TEST
+//TODO: add way to calibrate without flashing -> enter calibration mode with certain button sequence, enter steps-per-meter with poti, store in nvs
 
 //steps per meter
 //this value is determined experimentally while ENCODER_TEST is enabled
-#define ENCODER_STEPS_PER_METER 2127 //roll-v3-gummi-86.6mm - d=89.8mm
+//#define ENCODER_STEPS_PER_METER 2127 //until 2024.03.13 roll-v3-gummi-86.6mm - d=89.8mm
+#define ENCODER_STEPS_PER_METER 2118 //2024.03.13 roll-v3-gummi measured 86.5mm
 
-//millimetres added to target length
+//millimeters added to target length
 //to ensure that length does not fall short when spool slightly rotates back after stop
 #define TARGET_LENGTH_OFFSET 0
 
-//millimetres lengthNow can be below lengthTarget to still stay in target_reached state
+//millimeters lengthNow can be below lengthTarget to still stay in target_reached state
 #define TARGET_REACHED_TOLERANCE 5
 
 

main/control.cpp

@@ -446,17 +446,21 @@ void task_control(void *pvParameter)
         displayTop.handle();
         displayBot.handle();
         //-- show encoder steps on display1 ---
-        sprintf(buf_disp1, "EN %05d", encoder_getSteps); //count
+        sprintf(buf_disp1, "EN %05d", encoder_getSteps()); //count
         displayTop.showString(buf_disp1);
         //--- show converted distance on display2 ---
         sprintf(buf_disp2, "Met %5.3f", (float)lengthNow/1000); //m
         displayBot.showString(buf_disp2);
-        //--- beep every 1m ---
+        //--- beep every 0.5m ---
-        //note: only works precicely in forward/positive direction
+        //note: only works precisely in forward/positive direction, in reverse it it beeps by tolerance too early
-        if (lengthNow % 1000 < 50) { //with tolerance in case of missed exact value
+        static int lengthBeeped = 0;
-            if (fabs(lengthNow - lengthBeeped) >= 900) { //dont beep multiple times at same meter
+        if (lengthNow % 500 < 50) { //with tolerance in case of missed exact value
-                //TODO: add case for reverse direction. currently beeps 0.1 too early
+            if (fabs(lengthNow - lengthBeeped) >= 400) { //dont beep multiple times at same distance
-                buzzer.beep(1, 400, 100 );
+                //TODO: add case for reverse direction. currently beeps 50mm too early
+                if (lengthNow % 1000 < 50) // 1m beep
+                    buzzer.beep(1, 400, 100);
+                else // 0.5m beep
+                    buzzer.beep(1, 200, 100);
                 lengthBeeped = lengthNow;
             }
         }

main/guide-stepper.cpp

@@ -13,8 +13,11 @@ extern "C"
 #include "global.hpp"
 #include "guide-stepper.hpp"
 #include "encoder.hpp"
+#include "shutdown.hpp"
 
 
+//macro to get smaller value out of two
+#define MIN(a, b) (((a) < (b)) ? (a) : (b))
 
 //---------------------
 //--- configuration ---
@@ -24,13 +27,20 @@ extern "C"
 
 #define STEPPER_TEST_TRAVEL 65     // mm
 
-#define MIN_MM 0
+#define MIN_MM 0 //TODO add feature so guide stays at zero for some steps (negative MIN_MM?), currently seems appropriate for even winding
-#define MAX_MM 97 //actual reel is 110, but currently guide turned out to stay at max position for too long TODO: cad: guide rolls closer together
+#define MAX_MM 95 //actual reel is 110, but currently guide turned out to stay at max position for too long
 #define POS_MAX_STEPS MAX_MM * STEPPER_STEPS_PER_MM
 #define POS_MIN_STEPS MIN_MM * STEPPER_STEPS_PER_MM
 
+//tolerance added to last stored position at previous shutdown.
+//When calibrating at startup the stepper moves for that sum to get track of zero position (ensure crashes into hardware limit for at least some time)
+#define AUTO_HOME_TRAVEL_ADD_TO_LAST_POS_MM 20
+#define MAX_TOTAL_AXIS_TRAVEL_MM 103 //max possible travel distance, needed for auto-home
+
+// speeds for testing with potentiometer (test task only)
 #define SPEED_MIN 2.0   // mm/s
 #define SPEED_MAX 70.0  // mm/s
+//note: actual speed is currently defined in config.h with STEPPER_SPEED_DEFAULT
 
 #define LAYER_THICKNESS_MM 5 //height of one cable layer on reel -> increase in radius
 #define D_CABLE 6
@@ -62,6 +72,16 @@ static QueueHandle_t queue_commandsGuideTask;
 //----- functions ------
 //----------------------
 
+//=============================
+//=== guide_getAxisPosSteps ===
+//=============================
+// return local variable posNow
+// needed at shutdown detection to store last axis position in nvs
+int guide_getAxisPosSteps(){
+    return posNow;
+}
+
+
 //==========================
 //==== guide_moveToZero ====
 //==========================
@@ -281,9 +301,23 @@ void task_stepper_ctl(void *pvParameter)
     float currentDiameter;
 
 
-    //initialize stepper and define zero-position at task start
+
+    //initialize stepper at task start
     init_stepper();
-    stepper_home(MAX_MM);
+    //define zero-position
+    // use last known position stored at last shutdown to reduce time crashing into hardware limit
+    int posLastShutdown = nvsReadLastAxisPosSteps();
+    if (posLastShutdown >= 0)
+    { // would be -1 when failed
+        ESP_LOGW(TAG, "auto-home: considerting pos last shutdown %dmm + tolerance %dmm",
+        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));
+    }
+    else { // default to max travel when read from nvs failed
+        stepper_home(MAX_TOTAL_AXIS_TRAVEL_MM);
+    }
 
     //repeatedly read changes in measured cable length and move axis accordingly
     while(1){

main/guide-stepper.hpp

@@ -13,4 +13,8 @@ void task_stepper_ctl(void *pvParameter);
 
 
 //tell stepper-control task to move cable guide to zero position
-void guide_moveToZero();
+void guide_moveToZero();
+
+// return local variable posNow that stores the current position of cable guide axis in steps
+// needed by shutdown to store last axis position in nvs
+int guide_getAxisPosSteps();

main/main.cpp

@@ -8,6 +8,7 @@ extern "C"
 #include "esp_system.h"
 #include "esp_log.h"
 #include "driver/adc.h"
+
 }
 
 #include "config.h"
@@ -17,6 +18,7 @@ extern "C"
 #include "switchesAnalog.hpp"
 #include "guide-stepper.hpp"
 #include "encoder.hpp"
+#include "shutdown.hpp"
 
 #include "stepper.hpp"
 
@@ -59,6 +61,8 @@ void init_gpios(){
     //initialize and configure ADC
     adc1_config_width(ADC_WIDTH_BIT_12); //=> max resolution 4096
     adc1_config_channel_atten(ADC_CHANNEL_POTI, ADC_ATTEN_DB_11); //max voltage
+
+    adc1_config_channel_atten(ADC_CHANNEL_SUPPLY_VOLTAGE, ADC_ATTEN_DB_11); //max voltage
 }
 
 
@@ -95,15 +99,21 @@ extern "C" void app_main()
     esp_log_level_set("switches-analog", ESP_LOG_WARN);
     esp_log_level_set("control", ESP_LOG_INFO);
     esp_log_level_set("stepper-driver", ESP_LOG_WARN);
-    esp_log_level_set("stepper-ctrl", ESP_LOG_INFO);
+    esp_log_level_set("stepper-ctrl", ESP_LOG_WARN);
     esp_log_level_set("Dendostepper", ESP_LOG_WARN); //stepper lib
     esp_log_level_set("calc", ESP_LOG_WARN); //stepper lib
+    esp_log_level_set("lowVoltage", ESP_LOG_INFO);
 
 #ifdef STEPPER_TEST
     //create task for testing the stepper motor
     xTaskCreate(task_stepper_test, "task_stepper_test", configMINIMAL_STACK_SIZE * 3, NULL, 2, NULL);
     //xTaskCreate(task_stepper_debug, "task_stepper_test", configMINIMAL_STACK_SIZE * 3, NULL, 2, NULL);
 #else
+    //create task for detecting power-off
+    xTaskCreate(&task_shutDownDetection, "task_shutdownDet", 2048, NULL, 2, NULL);
+    // wait for nvs to be initialized in shutDownDetection task
+    vTaskDelay(50 / portTICK_PERIOD_MS);
+
     //create task for controlling the machine
     xTaskCreate(task_control, "task_control", configMINIMAL_STACK_SIZE * 3, NULL, 4, NULL);
 

main/shutdown.cpp

@@ -0,0 +1,120 @@
+extern "C"
+{
+#include <stdio.h>
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
+#include "esp_system.h"
+#include "esp_log.h"
+#include "driver/adc.h"
+#include "nvs_flash.h"
+#include "nvs.h"
+}
+
+#include "config.h"
+#include "shutdown.hpp"
+
+#include "guide-stepper.hpp"
+
+#define ADC_LOW_VOLTAGE_THRESHOLD 3200 // adc value where shut down is detected (store certain values before complete power loss)
+
+static const char *TAG = "lowVoltage"; // tag for logging
+nvs_handle_t nvsHandle; // access nvs that was opened once, in any function
+
+
+
+// store a u32 value in nvs as "lastPosSteps"
+void nvsWriteLastAxisPos(uint32_t value)
+{
+    // update nvs value
+    esp_err_t err = nvs_set_u32(nvsHandle, "lastPosSteps", 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 in nvs to %d", value);
+}
+
+
+
+// read "lastPosSteps" from nvs, returns -1 if failed
+int nvsReadLastAxisPosSteps()
+{
+    uint32_t valueRead;
+    esp_err_t err = nvs_get_u32(nvsHandle, "lastPosSteps", &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", "lastPosSteps");
+        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
+void task_shutDownDetection(void *pvParameter)
+{
+    //--- Initialize NVS ---
+    ESP_LOGW(TAG, "initializing nvs...");
+    esp_err_t err = nvs_flash_init();
+    if (err == ESP_ERR_NVS_NO_FREE_PAGES || err == ESP_ERR_NVS_NEW_VERSION_FOUND)
+    {
+        ESP_LOGE(TAG, "NVS truncated -> deleting flash");
+        // Retry nvs_flash_init
+        ESP_ERROR_CHECK(nvs_flash_erase());
+        err = nvs_flash_init();
+    }
+
+    //--- open nvs-flash ---
+    ESP_LOGW(TAG, "opening NVS-handle...");
+    // create handle available for all functions in this file
+    err = nvs_open("storage", NVS_READWRITE, &nvsHandle);
+    if (err != ESP_OK)
+        ESP_LOGE(TAG, "Error (%s) opening NVS handle!\n", esp_err_to_name(err));
+
+    // read stored value (returns 0 if unitialized/failed)
+    //int lastPosSteps = nvsReadLastAxisPosSteps();
+    //ESP_LOGW(TAG, "=> read value %d from nvs (stored at last shutdown)", lastPosSteps);
+
+    // repeatedly read ADC and check if below low voltage threshold
+    bool voltageBelowThreshold = false;
+    while (1) //TODO limit save frequency in case voltage repeadedly varys between threshold for some reason (e.g. offset drift)
+    {
+        // read adc
+        int adc_reading = adc1_get_raw(ADC_CHANNEL_SUPPLY_VOLTAGE);
+
+        // evaulate threshold
+        if (adc_reading < ADC_LOW_VOLTAGE_THRESHOLD) // below threshold => POWER SHUTDOWN DETECTED
+        {
+            // 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);
+                voltageBelowThreshold = true;
+            }
+        }
+        else if (voltageBelowThreshold) // above threshold and previously below
+        {
+            // log at change to above
+            ESP_LOGE(TAG, "voltage above threshold again: %d > %d - issue with power supply, or too threshold too high?", adc_reading, ADC_LOW_VOLTAGE_THRESHOLD);
+            voltageBelowThreshold = false;
+        }
+
+        // always log for debugging/calibrating
+        ESP_LOGD(TAG, "read adc battery voltage: %d", adc_reading);
+
+        vTaskDelay(30 / portTICK_PERIOD_MS);
+    }
+}

main/shutdown.hpp

@@ -0,0 +1,7 @@
+
+// task that repeatedly checks supply voltage (12V) and saves certain values to nvs in case of it drops below a certain threshold (power off detected)
+void task_shutDownDetection(void *pvParameter);
+
+// read last axis position in steps from nvs
+// returns -1 when reading from nvs failed
+int nvsReadLastAxisPosSteps();

main/stepper.cpp

@@ -160,7 +160,7 @@ void stepper_waitForStop(uint32_t timeoutMs){
 //Currently simply runs stepper for travelMm and bumps into hardware limit
 void stepper_home(uint32_t travelMm){
 	//TODO add timeout, limitswitch...
-	ESP_LOGW(TAG, "initiate auto-home...");
+	ESP_LOGW(TAG, "initiate auto-home, moving %d mm...", travelMm);
 	posNow = travelMm * STEPPER_STEPS_PER_MM;
 	while (posNow != 0){
 		//reactivate just in case stopped by other call to prevent deadlock