j/cable-length-cutter
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Switch to and Add travelSteps beside travelMm (WIP)

Browse Source 
- optimize some variable and macro names
- change/add function that travels guide certain steps
- stepper task: - calculate steps depending on encoder steps
                - move steps if at least 1 step possible
- prepare poti modifier

-> untested
This commit is contained in:
jonny_ji7 2023-03-01 12:56:24 +01:00
parent 118e9714b5
commit 226aa4794c
2 changed files with 79 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

146
main/guide-stepper.cpp
View File

@ -22,8 +22,10 @@ extern "C"
#define STEPPER_TEST_TRAVEL 65 //mm #define STEPPER_TEST_TRAVEL 65 //mm
// //
#define MIN 0 #define MIN_MM 0
#define MAX 60 #define MAX_MM 60
#define POS_MAX_STEPS MAX_MM * STEPPER_STEPS_PER_MM
#define POS_MIN_STEPS MIN_MM * STEPPER_STEPS_PER_MM
#define SPEED_MIN 2.0 //mm/s #define SPEED_MIN 2.0 //mm/s
@ -47,90 +49,72 @@ extern "C"
static DendoStepper step; static DendoStepper step;
static const char *TAG = "stepper"; //tag for logging static const char *TAG = "stepper"; //tag for logging
static int stepp_lengthNow = 0; //length measured in mm
static int lengthPrev = 0; //length last check
static bool stepp_direction = true; static bool stepp_direction = true;
static uint64_t posNow = 0; static uint32_t posNow = 0;
//---------------------- //----------------------
//----- functions ------ //----- functions ------
//---------------------- //----------------------
//move left and right or reverse while winding //move axis certain Steps (relative) between left and right or reverse when negative
void travelDist(int length){ void travelSteps(int stepsTarget){
//uint64_t posNow = step.getPositionMm(); //posNow = step.getPositionMm(); //not otherwise controlled, so no update necessary
int stepsToGo, remaining;
int d, remaining; stepsToGo = abs(stepsTarget);
d = abs(length); if(stepsTarget < 0) stepp_direction = !stepp_direction; //invert direction in reverse mode
if(length < 0) stepp_direction = !stepp_direction; //invert direction in reverse mode
while (d != 0){ while (stepsToGo != 0){
//--- currently moving right --- //--- currently moving right ---
if (stepp_direction == true){ //currently moving right if (stepp_direction == true){ //currently moving right
remaining = MAX - posNow; //calc remaining distance fom current position to limit remaining = POS_MAX_STEPS - posNow; //calc remaining distance fom current position to limit
if (d > remaining){ //new distance will exceed limit if (stepsToGo > remaining){ //new distance will exceed limit
step.runAbsMm (MAX); //move to limit step.runAbs (POS_MAX_STEPS); //move to limit
posNow=MAX; while(step.getState() != 1) vTaskDelay(2); //wait for move to finish
posNow = POS_MAX_STEPS;
stepp_direction = false; //change current direction for next iteration stepp_direction = false; //change current direction for next iteration
d = d - remaining; //decrease target length by already traveled distance stepsToGo = stepsToGo - remaining; //decrease target length by already traveled distance
printf(" --- changed direction (L) --- \n "); ESP_LOGI(TAG, " --- moved to max -> change direction (L) --- \n ");
} }
else { //target distance does not reach the limit else { //target distance does not reach the limit
step.runAbsMm (posNow + d); //move by (remaining) distance to reach target length step.runAbs (posNow + stepsToGo); //move by (remaining) distance to reach target length
printf("moving to %lld\n", posNow+d); while(step.getState() != 1) vTaskDelay(2); //wait for move to finish
posNow += d; ESP_LOGD(TAG, "moving to %d\n", posNow+stepsToGo);
d = 0; //finished, reset target length (could as well exit loop/break) posNow += stepsToGo;
stepsToGo = 0; //finished, reset target length (could as well exit loop/break)
} }
} }
//--- currently moving left --- //--- currently moving left ---
else { else {
remaining = posNow - MIN; remaining = posNow - POS_MIN_STEPS;
if (d > remaining){ if (stepsToGo > remaining){
step.runAbsMm (MIN); step.runAbs (POS_MIN_STEPS);
posNow=0; while(step.getState() != 1) vTaskDelay(2); //wait for move to finish
posNow = POS_MIN_STEPS;
stepp_direction = true; stepp_direction = true;
d = d - remaining; stepsToGo = stepsToGo - remaining;
printf(" --- changed direction (R) --- \n "); ESP_LOGI(TAG, " --- moved to min -> change direction (R) --- \n ");
} }
else { else {
step.runAbsMm (posNow - d); //when moving left the coordinate has to be decreased step.runAbs (posNow - stepsToGo); //when moving left the coordinate has to be decreased
printf("moving to %lld\n", posNow-d); while(step.getState() != 1) vTaskDelay(2); //wait for move to finish
posNow -= d; ESP_LOGD(TAG, "moving to %d\n", posNow - stepsToGo);
d = 0; posNow -= stepsToGo;
stepsToGo = 0;
} }
} }
} }
if(stepsTarget < 0) stepp_direction = !stepp_direction; //undo inversion of stepp_direction after reverse mode is finished
if(length < 0) stepp_direction = !stepp_direction; //undo inversion of stepp_direction after reverse mode is finished
return; return;
} }
//move axis certain Mm (relative) between left and right or reverse when negative
void travelMm(int length){
travelSteps(length * STEPPER_STEPS_PER_MM);
}
//calculate time needed for certain length (NOT NEEDED/ DELETE)
//float mmToS(int l){
//
// double accel = SPEED_MAX / (ACCEL_MS/1000);
// double t_accelMax = ACCEL_MS/1000;
// double l_accelMax = accel * t_accelMax * t_accelMax;
//
// printf("accel=%.2lf mm/s2 __ t_accelMAX=%.2lfs __ l_accelMax=%.2lfmm\n", accel, t_accelMax, l_accelMax);
// if (l < l_accelMax){
// return sqrt(l / accel);
// } else {
// return t_accelMax + (l - l_accelMax) / SPEED_MAX;
// }
//}
//define zero/start position //define zero/start position
@ -140,7 +124,7 @@ void home() {
ESP_LOGW(TAG, "auto-home..."); ESP_LOGW(TAG, "auto-home...");
step.setSpeedMm(120, 120, 100); step.setSpeedMm(120, 120, 100);
step.runInf(0); step.runInf(0);
vTaskDelay(2000 / portTICK_PERIOD_MS); vTaskDelay(1500 / portTICK_PERIOD_MS);
step.stop(); step.stop();
step.resetAbsolute(); step.resetAbsolute();
ESP_LOGW(TAG, "auto-home finished"); ESP_LOGW(TAG, "auto-home finished");
@ -177,9 +161,9 @@ void updateSpeedFromAdc() {
//--------------------- //----------------------------
//------- TASK -------- //---- TASK stepper-test -----
//--------------------- //----------------------------
void task_stepper_test(void *pvParameter) void task_stepper_test(void *pvParameter)
{ {
init_stepper(); init_stepper();
@ -199,29 +183,49 @@ void task_stepper_test(void *pvParameter)
} }
//----------------------------
//----- TASK stepper-ctl -----
//----------------------------
void task_stepper_ctl(void *pvParameter) void task_stepper_ctl(void *pvParameter)
{ {
//variables
int encStepsNow = 0; //get curret steps of encoder
int encStepsPrev = 0; //steps at last check
int encStepsDelta = 0; //steps changed since last iteration
double stepsTravel = 0; //steps axis hast to travel
init_stepper(); init_stepper();
home(); home();
while(1){ while(1){
//get current length //get current length
stepp_lengthNow = encoder_getLenMm(); encStepsNow = encoder_getSteps();
int lengthDelta = stepp_lengthNow - lengthPrev; //calculate change
encStepsDelta = encStepsNow - encStepsPrev; //FIXME MAJOR BUG: when resetting encoder/length in control task, diff will be huge!
//TODO add modifier e.g. poti value //TODO add modifier e.g. poti value
int travel = lengthDelta * D_CABLE / (PI * D_REEL); //calc distance to move
ESP_LOGI(TAG, "delta: %d travel: %d",lengthDelta, travel); //read potentiometer for calibration
//FIXME: rounding issue? e.g. 1.4 gets lost float potiModifier = (float) 4095 / gpio_readAdc(ADC_CHANNEL_POTI); //0-4095 -> 0-1
if (abs(travel) > 1){ //when ready to move axis by at least 1 millimeter ESP_LOGI(TAG, "current poti-modifier = %f", potiModifier);
ESP_LOGI(TAG, "EXCEEDED: delta: %d travel: %d",lengthDelta, travel);
travelDist(travel); //calculate steps moved
//steps-axis = (length moved in mm) * (travel distance per length) * (stepper steps per mm)
stepsTravel = (float) (encStepsDelta * 1000 / ENCODER_STEPS_PER_METER) * (D_CABLE/(PI*D_REEL)) * (STEPPER_STEPS_PER_MM);
//FIXME: rounding issue? e.g. 1.4 steps gets lost
ESP_LOGD(TAG, "stepsDelta: %d stepsTravel: %lf",encStepsDelta, stepsTravel);
//move axis when ready to move at least 1 step
if (abs((int)stepsTravel) > 1){
ESP_LOGI(TAG, "MOVING %d steps",(int)stepsTravel);
travelSteps((int)stepsTravel);
while(step.getState() != 1) vTaskDelay(2); //wait for move to finish while(step.getState() != 1) vTaskDelay(2); //wait for move to finish
lengthPrev = stepp_lengthNow; //update length encStepsPrev = encStepsNow; //update length
} }
else { else {
//TODO use encoder queue to only run this check at encoder event?
vTaskDelay(5); vTaskDelay(5);
} }
} }
} }

2
main/main.cpp
View File

@ -86,7 +86,7 @@ extern "C" void app_main()
esp_log_level_set("buzzer", ESP_LOG_ERROR); esp_log_level_set("buzzer", ESP_LOG_ERROR);
esp_log_level_set("switches-analog", ESP_LOG_WARN); esp_log_level_set("switches-analog", ESP_LOG_WARN);
esp_log_level_set("control", ESP_LOG_INFO); esp_log_level_set("control", ESP_LOG_INFO);
esp_log_level_set("stepper", ESP_LOG_INFO); esp_log_level_set("stepper", ESP_LOG_DEBUG);
#ifdef STEPPER_TEST #ifdef STEPPER_TEST
//create task for stepper testing //create task for stepper testing