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

Add layer-count, variable diameter, Optimize comments

Browse Source 
guide-stepper:
    - Add layer count when reversing axis
    - Adjust steps calculation considering (add layers to reel-dia)
    - optimize comments
control: optimize comments
main: optimize comments
This commit is contained in:
jonny 2024-03-09 09:42:18 +01:00 committed by jonny_l480
parent 989f9cce13
commit e65350f643
4 changed files with 105 additions and 73 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
main/config.hpp
View File

@ -48,8 +48,6 @@ extern "C" {
#define SW_PRESET3 sw_gpio_analog_3 #define SW_PRESET3 sw_gpio_analog_3
#define SW_CUT sw_gpio_33 #define SW_CUT sw_gpio_33
#define SW_AUTO_CUT sw_gpio_32 #define SW_AUTO_CUT sw_gpio_32
//unused but already available evaluated inputs
//#define ? sw_gpio_34 //#define ? sw_gpio_34
@ -90,7 +88,7 @@ extern "C" {
#define STEPPER_STEP_PIN GPIO_NUM_18 //mos1 #define STEPPER_STEP_PIN GPIO_NUM_18 //mos1
#define STEPPER_DIR_PIN GPIO_NUM_16 //ST3 #define STEPPER_DIR_PIN GPIO_NUM_16 //ST3
//driver settings //driver settings
#define STEPPER_STEPS_PER_MM 200/2 //steps/mm (steps-per-rot / 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 20 //mm/s
#define STEPPER_SPEED_MIN 4 //mm/s - speed threshold at which stepper immediately starts/stops #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_ACCEL_INC 3 //steps/s increment per cycle
@ -107,6 +105,7 @@ extern "C" {
//#define ENCODER_TEST //#define ENCODER_TEST
//steps per meter //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 //roll-v3-gummi-86.6mm - d=89.8mm
//millimetres added to target length //millimetres added to target length

94
main/control.cpp
View File

@ -3,14 +3,15 @@
#include "guide-stepper.hpp" #include "guide-stepper.hpp"
//==================== //--------------------
//==== variables ===== //---- variables -----
//==================== //--------------------
static const char *TAG = "control"; //tag for logging static const char *TAG = "control"; //tag for logging
const char* systemStateStr[7] = {"COUNTING", "WINDING_START", "WINDING", "TARGET_REACHED", "AUTO_CUT_WAITING", "CUTTING", "MANUAL"}; const char* systemStateStr[7] = {"COUNTING", "WINDING_START", "WINDING", "TARGET_REACHED", "AUTO_CUT_WAITING", "CUTTING", "MANUAL"};
systemState_t controlState = systemState_t::COUNTING; systemState_t controlState = systemState_t::COUNTING;
static uint32_t timestamp_changedState = 0; static uint32_t timestamp_lastStateChange = 0;
static char buf_disp1[10];// 8 digits + decimal point + \0 static char buf_disp1[10];// 8 digits + decimal point + \0
static char buf_disp2[10];// 8 digits + decimal point + \0 static char buf_disp2[10];// 8 digits + decimal point + \0
@ -29,7 +30,14 @@ static uint32_t autoCut_delayMs = 2500; //TODO add this to config
static bool autoCutEnabled = false; //store state of toggle switch (no hotswitch) static bool autoCutEnabled = false; //store state of toggle switch (no hotswitch)
//--------------------
//---- functions -----
//--------------------
//========================
//===== change State ===== //===== change State =====
//========================
//function for changing the controlState with log output //function for changing the controlState with log output
void changeState (systemState_t stateNew) { void changeState (systemState_t stateNew) {
//only proceed when state actually changed //only proceed when state actually changed
@ -41,12 +49,14 @@ void changeState (systemState_t stateNew) {
//change state //change state
controlState = stateNew; controlState = stateNew;
//update timestamp //update timestamp
timestamp_changedState = esp_log_timestamp(); timestamp_lastStateChange = esp_log_timestamp();
} }
//=================================
//===== handle Stop Condition ===== //===== handle Stop Condition =====
//=================================
//function that checks whether start button is released or target is reached (used in multiple states) //function that checks whether start button is released or target is reached (used in multiple states)
//returns true when stopped, false when no action //returns true when stopped, false when no action
bool handleStopCondition(handledDisplay * displayTop, handledDisplay * displayBot){ bool handleStopCondition(handledDisplay * displayTop, handledDisplay * displayBot){
@ -75,8 +85,11 @@ bool handleStopCondition(handledDisplay * displayTop, handledDisplay * displayBo
} }
//===================================
//===== set dynamic speed level ===== //===== set dynamic speed level =====
//function that sets the vfd speed level dynamicly depending on the remaining distance //===================================
//function that sets the vfd speed level dynamically depending on the remaining distance
//closer to target -> slower //closer to target -> slower
void setDynSpeedLvl(uint8_t lvlMax = 3){ void setDynSpeedLvl(uint8_t lvlMax = 3){
uint8_t lvl; uint8_t lvl;
@ -104,30 +117,27 @@ void setDynSpeedLvl(uint8_t lvlMax = 3){
//======================== //========================
//===== control task ===== //===== control task =====
//======================== //========================
//task that controls the entire machine
void task_control(void *pvParameter) void task_control(void *pvParameter)
{ {
//initialize display //-- initialize display --
max7219_t two7SegDisplays = display_init(); max7219_t two7SegDisplays = display_init();
//create two separate handled display instances //create two separate custom handled display instances
handledDisplay displayTop(two7SegDisplays, 0); handledDisplay displayTop(two7SegDisplays, 0);
handledDisplay displayBot(two7SegDisplays, 8); handledDisplay displayBot(two7SegDisplays, 8);
//--- display welcome msg --- //-- display welcome msg --
//display welcome message on two 7 segment displays //display welcome message on two 7 segment displays
//currently show name and date and scrolling 'hello' //currently show name and date and scrolling 'hello'
display_ShowWelcomeMsg(two7SegDisplays); display_ShowWelcomeMsg(two7SegDisplays);
//================
//===== loop ===== //===== loop =====
//================
while(1){ while(1){
vTaskDelay(10 / portTICK_PERIOD_MS); vTaskDelay(10 / portTICK_PERIOD_MS);
//-----------------------------
//------ handle switches ------ //------ handle switches ------
//-----------------------------
//run handle functions for all switches //run handle functions for all switches
SW_START.handle(); SW_START.handle();
SW_RESET.handle(); SW_RESET.handle();
@ -139,28 +149,23 @@ void task_control(void *pvParameter)
SW_AUTO_CUT.handle(); SW_AUTO_CUT.handle();
//---------------------------
//------ handle cutter ------ //------ handle cutter ------
//--------------------------- //TODO: separate task for cutter?
cutter_handle(); cutter_handle();
//----------------------------
//------ rotary encoder ------ //------ rotary encoder ------
//---------------------------- //get current length since last reset
//--- get current length since last reset ---
lengthNow = encoder_getLenMm(); lengthNow = encoder_getLenMm();
//---------------------------
//--------- buttons --------- //--------- buttons ---------
//--------------------------- //#### RESET switch ####
//--- RESET switch ---
if (SW_RESET.risingEdge) { if (SW_RESET.risingEdge) {
//dont reset when press used for stopping pending auto-cut //dont reset when press used for stopping pending auto-cut
if (controlState != systemState_t::AUTO_CUT_WAITING) { if (controlState != systemState_t::AUTO_CUT_WAITING) {
guide_moveToZero(); guide_moveToZero(); //move axis guiding the cable to start position
encoder_reset(); encoder_reset(); //reset length measurement
lengthNow = 0; lengthNow = 0;
buzzer.beep(1, 700, 100); buzzer.beep(1, 700, 100);
displayTop.blink(2, 100, 100, "1ST "); displayTop.blink(2, 100, 100, "1ST ");
@ -169,7 +174,7 @@ void task_control(void *pvParameter)
} }
} }
//--- CUT switch --- //### CUT switch ####
//start cut cycle immediately //start cut cycle immediately
if (SW_CUT.risingEdge) { if (SW_CUT.risingEdge) {
//stop cutter if already running //stop cutter if already running
@ -192,7 +197,7 @@ void task_control(void *pvParameter)
} }
} }
//--- AUTO_CUT toggle sw --- //#### AUTO_CUT toggle sw ####
//beep at change //beep at change
if (SW_AUTO_CUT.risingEdge) { if (SW_AUTO_CUT.risingEdge) {
buzzer.beep(2, 100, 50); buzzer.beep(2, 100, 50);
@ -211,7 +216,7 @@ void task_control(void *pvParameter)
autoCutEnabled = false; autoCutEnabled = false;
} }
//--- manual mode --- //#### manual mode ####
//switch to manual motor control (2 buttons + poti) //switch to manual motor control (2 buttons + poti)
if ( SW_PRESET2.state && (SW_PRESET1.state || SW_PRESET3.state) && controlState != systemState_t::MANUAL ) { if ( SW_PRESET2.state && (SW_PRESET1.state || SW_PRESET3.state) && controlState != systemState_t::MANUAL ) {
//enable manual control //enable manual control
@ -219,7 +224,7 @@ void task_control(void *pvParameter)
buzzer.beep(3, 100, 60); buzzer.beep(3, 100, 60);
} }
//--- set custom target length --- //##### custom target length using poti #####
//set target length to poti position when SET switch is pressed //set target length to poti position when SET switch is pressed
if (SW_SET.state == true) { if (SW_SET.state == true) {
//read adc //read adc
@ -255,7 +260,7 @@ void task_control(void *pvParameter)
} }
//--- target length presets --- //##### target length preset buttons #####
if (controlState != systemState_t::MANUAL) { //dont apply preset length while controlling motor with preset buttons if (controlState != systemState_t::MANUAL) { //dont apply preset length while controlling motor with preset buttons
if (SW_PRESET1.risingEdge) { if (SW_PRESET1.risingEdge) {
lengthTarget = 5000; lengthTarget = 5000;
@ -275,16 +280,17 @@ void task_control(void *pvParameter)
} }
//--------------------------- //---------------------------
//--------- control --------- //--------- control ---------
//--------------------------- //---------------------------
//calculate length difference //statemachine handling the sequential winding process
//calculate current length difference
lengthRemaining = lengthTarget - lengthNow + TARGET_LENGTH_OFFSET; lengthRemaining = lengthTarget - lengthNow + TARGET_LENGTH_OFFSET;
//--- statemachine --- //--- statemachine ---
switch (controlState) { switch (controlState) {
case systemState_t::COUNTING: //no motor action case systemState_t::COUNTING: //no motor action, just show current length on display
vfd_setState(false); vfd_setState(false);
//TODO check stop condition before starting - prevents motor from starting 2 cycles when already at target //TODO check stop condition before starting - prevents motor from starting 2 cycles when already at target
//--- start winding to length --- //--- start winding to length ---
@ -300,6 +306,7 @@ void task_control(void *pvParameter)
case systemState_t::WINDING_START: //wind slow for certain time case systemState_t::WINDING_START: //wind slow for certain time
//set vfd speed depending on remaining distance //set vfd speed depending on remaining distance
setDynSpeedLvl(1); //limit to speed lvl 1 (force slow start) setDynSpeedLvl(1); //limit to speed lvl 1 (force slow start)
//switch to WINDING state (full speed) when 3s have passed
if (esp_log_timestamp() - timestamp_motorStarted > 3000) { if (esp_log_timestamp() - timestamp_motorStarted > 3000) {
changeState(systemState_t::WINDING); changeState(systemState_t::WINDING);
} }
@ -309,23 +316,23 @@ void task_control(void *pvParameter)
case systemState_t::WINDING: //wind fast, slow down when close 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 setDynSpeedLvl(); //set motor speed, slow down when close to target
handleStopCondition(&displayTop, &displayBot); //stops if button released or target reached 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; break;
case systemState_t::TARGET_REACHED: case systemState_t::TARGET_REACHED: //prevent further motor rotation and start auto-cut
vfd_setState(false); vfd_setState(false);
//switch to counting state when no longer at or above target length //switch to counting state when no longer at or above target length
if ( lengthNow < lengthTarget - TARGET_REACHED_TOLERANCE ) { if ( lengthNow < lengthTarget - TARGET_REACHED_TOLERANCE ) {
changeState(systemState_t::COUNTING); changeState(systemState_t::COUNTING);
} }
//switch initiate countdown to auto-cut //initiate countdown to auto-cut if enabled
else if ( (autoCutEnabled) else if ( (autoCutEnabled)
&& (esp_log_timestamp() - timestamp_changedState > 300) ) { //wait for dislay msg "reached" to finish && (esp_log_timestamp() - timestamp_lastStateChange > 300) ) { //wait for dislay msg "reached" to finish
changeState(systemState_t::AUTO_CUT_WAITING); changeState(systemState_t::AUTO_CUT_WAITING);
} }
//show msg when trying to start, but target is reached //show msg when trying to start, but target is already reached (-> reset button has to be pressed)
if (SW_START.risingEdge) { if (SW_START.risingEdge) {
buzzer.beep(2, 50, 30); buzzer.beep(2, 50, 30);
displayTop.blink(2, 600, 500, " S0LL "); displayTop.blink(2, 600, 500, " S0LL ");
@ -333,9 +340,8 @@ void task_control(void *pvParameter)
} }
break; break;
case systemState_t::AUTO_CUT_WAITING: case systemState_t::AUTO_CUT_WAITING: //handle delayed start of cut
//handle delayed start of cut cut_msRemaining = autoCut_delayMs - (esp_log_timestamp() - timestamp_lastStateChange);
cut_msRemaining = autoCut_delayMs - (esp_log_timestamp() - timestamp_changedState);
//- countdown stop conditions - //- countdown stop conditions -
//stop with any button //stop with any button
if (!autoCutEnabled if (!autoCutEnabled
@ -359,14 +365,14 @@ void task_control(void *pvParameter)
} }
break; break;
case systemState_t::CUTTING: case systemState_t::CUTTING: //prevent any action while cutter is active
//exit when finished cutting //exit when finished cutting
if (cutter_isRunning() == false) { if (cutter_isRunning() == false) {
//TODO stop if start buttons released? //TODO stop if start buttons released?
changeState(systemState_t::COUNTING); changeState(systemState_t::COUNTING);
//TODO reset automatically or wait for manual reset? //TODO reset automatically or wait for manual reset?
guide_moveToZero(); guide_moveToZero(); //move axis guiding the cable to start position
encoder_reset(); encoder_reset(); //reset length measurement
lengthNow = 0; lengthNow = 0;
buzzer.beep(1, 700, 100); buzzer.beep(1, 700, 100);
} }
@ -499,6 +505,6 @@ void task_control(void *pvParameter)
#endif #endif
} } //end while(1)
} } //end task_control

65
main/guide-stepper.cpp
View File

@ -32,7 +32,7 @@ extern "C"
#define SPEED_MAX 60.0 //mm/s #define SPEED_MAX 60.0 //mm/s
#define D_CABLE 6 #define D_CABLE 6
#define D_REEL 160 //actual 170 #define D_REEL 160
#define PI 3.14159 #define PI 3.14159
@ -43,11 +43,15 @@ extern "C"
//---------------------- //----------------------
//----- variables ------ //----- variables ------
//---------------------- //----------------------
typedef enum axisDirection_t {LEFT = 0, RIGHT} axisDirection_t;
static const char *TAG = "stepper-ctrl"; //tag for logging static const char *TAG = "stepper-ctrl"; //tag for logging
static bool stepp_direction = true; static axisDirection_t currentAxisDirection = RIGHT;
static uint32_t posNow = 0; static uint32_t posNow = 0;
static int layerCount = 0;
// queue for sending commands to task handling guide movement // queue for sending commands to task handling guide movement
static QueueHandle_t queue_commandsGuideTask; static QueueHandle_t queue_commandsGuideTask;
@ -75,17 +79,24 @@ void travelSteps(int stepsTarget){
int stepsToGo, remaining; int stepsToGo, remaining;
stepsToGo = abs(stepsTarget); stepsToGo = abs(stepsTarget);
if(stepsTarget < 0) stepp_direction = !stepp_direction; //invert direction in reverse mode
// invert direction in reverse mode (cable gets spooled off reel)
if (stepsTarget < 0) {
currentAxisDirection = (currentAxisDirection == LEFT) ? RIGHT : LEFT; //toggle between RIGHT<->Left
}
while (stepsToGo != 0){ while (stepsToGo != 0){
//--- currently moving right --- //--- currently moving right ---
if (stepp_direction == true){ //currently moving right if (currentAxisDirection == RIGHT){ //currently moving right
remaining = POS_MAX_STEPS - posNow; //calc remaining distance fom current position to limit remaining = POS_MAX_STEPS - posNow; //calc remaining distance fom current position to limit
if (stepsToGo > remaining){ //new distance will exceed limit if (stepsToGo > remaining){ //new distance will exceed limit
stepper_setTargetPosSteps(POS_MAX_STEPS); //move to limit stepper_setTargetPosSteps(POS_MAX_STEPS); //move to limit
stepper_waitForStop(1000); stepper_waitForStop(1000);
posNow = POS_MAX_STEPS; posNow = POS_MAX_STEPS;
stepp_direction = false; //change current direction for next iteration currentAxisDirection = LEFT; //change current direction for next iteration
//increment/decrement layer count depending on current cable direction
layerCount += (stepsTarget > 0) - (stepsTarget < 0);
if (layerCount < 0) layerCount = 0; //negative layers are not possible
stepsToGo = stepsToGo - remaining; //decrease target length by already traveled distance stepsToGo = stepsToGo - remaining; //decrease target length by already traveled distance
ESP_LOGI(TAG, " --- moved to max -> change direction (L) --- \n "); ESP_LOGI(TAG, " --- moved to max -> change direction (L) --- \n ");
} }
@ -98,13 +109,16 @@ void travelSteps(int stepsTarget){
} }
//--- currently moving left --- //--- currently moving left ---
else { else if (currentAxisDirection == LEFT){
remaining = posNow - POS_MIN_STEPS; remaining = posNow - POS_MIN_STEPS;
if (stepsToGo > remaining){ if (stepsToGo > remaining){
stepper_setTargetPosSteps(POS_MIN_STEPS); stepper_setTargetPosSteps(POS_MIN_STEPS);
stepper_waitForStop(1000); stepper_waitForStop(1000);
posNow = POS_MIN_STEPS; posNow = POS_MIN_STEPS;
stepp_direction = true; currentAxisDirection = RIGHT; //switch direction
//increment/decrement layer count depending on current cable direction
layerCount += (stepsTarget > 0) - (stepsTarget < 0);
if (layerCount < 0) layerCount = 0; //negative layers are not possible
stepsToGo = stepsToGo - remaining; stepsToGo = stepsToGo - remaining;
ESP_LOGI(TAG, " --- moved to min -> change direction (R) --- \n "); ESP_LOGI(TAG, " --- moved to min -> change direction (R) --- \n ");
} }
@ -116,7 +130,12 @@ void travelSteps(int stepsTarget){
} }
} }
} }
if(stepsTarget < 0) stepp_direction = !stepp_direction; //undo inversion of stepp_direction after reverse mode is finished
// undo inversion of currentAxisDirection after reverse mode is finished
if (stepsTarget < 0) {
currentAxisDirection = (currentAxisDirection == LEFT) ? RIGHT : LEFT; //toggle between RIGHT<->Left
}
return; return;
} }
@ -230,23 +249,28 @@ void task_stepper_test(void *pvParameter)
void task_stepper_ctl(void *pvParameter) void task_stepper_ctl(void *pvParameter)
#endif #endif
{ {
//variables //-- variables --
int encStepsNow = 0; //get curret steps of encoder static int encStepsPrev = 0; //measured encoder steps at last run
int encStepsPrev = 0; //steps at last check static double travelStepsPartial = 0; //store resulted remaining partial steps last run
int encStepsDelta = 0; //steps changed since last iteration
//temporary variables for calculating required steps, or logging
int encStepsNow = 0; //get curretly measured steps of encoder
int encStepsDelta = 0; //encoder steps changed since last iteration
double cableLen = 0; double cableLen = 0;
double travelStepsExact = 0; //steps axis has to travel double travelStepsExact = 0; //steps axis has to travel
double travelStepsPartial = 0;
int travelStepsFull = 0; int travelStepsFull = 0;
double travelMm = 0; double travelMm = 0;
double turns = 0; double turns = 0;
float currentDiameter;
float potiModifier; float potiModifier;
//initialize stepper and define zero-position at task start
init_stepper(); init_stepper();
stepper_home(MAX_MM); stepper_home(MAX_MM);
//repeatedly read changes in measured cable length and move axis accordingly
while(1){ while(1){
#ifdef STEPPER_SIMULATE_ENCODER #ifdef STEPPER_SIMULATE_ENCODER
//TESTING - simulate encoder using switch //TESTING - simulate encoder using switch
@ -258,7 +282,7 @@ void task_stepper_ctl(void *pvParameter)
encStepsNow = encoder_getSteps(); encStepsNow = encoder_getSteps();
#endif #endif
// move to zero if command received via queue // move to zero and reset if command received via queue
bool receivedValue; bool receivedValue;
if (xQueueReceive(queue_commandsGuideTask, &receivedValue, 0) == pdTRUE) if (xQueueReceive(queue_commandsGuideTask, &receivedValue, 0) == pdTRUE)
{ {
@ -272,9 +296,10 @@ void task_stepper_ctl(void *pvParameter)
encStepsNow = encoder_getSteps(); encStepsNow = encoder_getSteps();
encStepsPrev = encStepsNow; encStepsPrev = encStepsNow;
travelStepsPartial = 0; travelStepsPartial = 0;
// set locally stored axis position to 0 (used for calculating the target axis coordinate) // set locally stored axis position and counted layers to 0 (used for calculating the target axis coordinate and steps)
posNow = 0; posNow = 0;
ESP_LOGW(TAG, "at position 0, resuming normal cable guiding operation"); layerCount = 0;
ESP_LOGW(TAG, "at position 0, reset variables, resuming normal cable guiding operation");
} }
//calculate change //calculate change
@ -290,16 +315,18 @@ void task_stepper_ctl(void *pvParameter)
//calculate steps to move //calculate steps to move
cableLen = (double)encStepsDelta * 1000 / ENCODER_STEPS_PER_METER; cableLen = (double)encStepsDelta * 1000 / ENCODER_STEPS_PER_METER;
turns = cableLen / (PI * D_REEL); // diameter increases each layer
currentDiameter = D_REEL + D_CABLE * layerCount; //TODO actually increases in radius per layer -> shoud be x2, but layer is not exactly 1D thick => test this
turns = cableLen / (PI * currentDiameter);
travelMm = turns * D_CABLE; travelMm = turns * D_CABLE;
travelStepsExact = travelMm * STEPPER_STEPS_PER_MM + travelStepsPartial; //convert mm to steps and add not moved partial steps travelStepsExact = travelMm * STEPPER_STEPS_PER_MM + travelStepsPartial; //convert mm to steps and add not moved partial steps
travelStepsPartial = 0; travelStepsPartial = 0;
travelStepsFull = (int)travelStepsExact; travelStepsFull = (int)travelStepsExact;
//move axis when ready to move at least 1 step //move axis when ready to move at least 1 full step
if (abs(travelStepsFull) > 1){ if (abs(travelStepsFull) > 1){
travelStepsPartial = fmod(travelStepsExact, 1); //save remaining partial steps to be added in the next iteration travelStepsPartial = fmod(travelStepsExact, 1); //save remaining partial steps to be added in the next iteration
ESP_LOGI(TAG, "cablelen=%.2lf, turns=%.2lf, travelMm=%.3lf, travelStepsExact: %.3lf, travelStepsFull=%d, partialStep=%.3lf", cableLen, turns, travelMm, travelStepsExact, travelStepsFull, travelStepsPartial); ESP_LOGI(TAG, "dCablelen=%.2lf, dTurns=%.2lf, travelMm=%.3lf, travelStepsExact: %.3lf, travelStepsFull=%d, partialStep=%.3lf, totalLayerCount=%d, diameter=%.1f", cableLen, turns, travelMm, travelStepsExact, travelStepsFull, travelStepsPartial, layerCount, currentDiameter);
ESP_LOGD(TAG, "MOVING %d steps", travelStepsFull); ESP_LOGD(TAG, "MOVING %d steps", travelStepsFull);
travelSteps(travelStepsExact); travelSteps(travelStepsExact);
encStepsPrev = encStepsNow; //update previous length encStepsPrev = encStepsNow; //update previous length

10
main/main.cpp
View File

@ -24,7 +24,7 @@ extern "C"
//=========== functions =========== //=========== functions ===========
//================================= //=================================
//--- configure output --- //--- configure output ---
//function to configure gpio pin as output //configure a gpio pin as output
void gpio_configure_output(gpio_num_t gpio_pin){ void gpio_configure_output(gpio_num_t gpio_pin){
gpio_pad_select_gpio(gpio_pin); gpio_pad_select_gpio(gpio_pin);
gpio_set_direction(gpio_pin, GPIO_MODE_OUTPUT); gpio_set_direction(gpio_pin, GPIO_MODE_OUTPUT);
@ -74,17 +74,17 @@ void task_buzzer( void * pvParameters ){
//====================================== //======================================
extern "C" void app_main() extern "C" void app_main()
{ {
//init outputs //init outputs and adc
init_gpios(); init_gpios();
//enable 5V volate regulator //enable 5V volage regulator
gpio_set_level(GPIO_NUM_17, 1); gpio_set_level(GPIO_NUM_17, 1);
//init encoder (global) //init encoder (global)
encoder_queue = encoder_init(); encoder_queue = encoder_init();
//define loglevel //define loglevel
esp_log_level_set("*", ESP_LOG_INFO); esp_log_level_set("*", ESP_LOG_INFO); //default loglevel
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);
@ -101,7 +101,7 @@ extern "C" void app_main()
//create task for controlling the machine //create task for controlling the machine
xTaskCreate(task_control, "task_control", configMINIMAL_STACK_SIZE * 3, NULL, 4, NULL); xTaskCreate(task_control, "task_control", configMINIMAL_STACK_SIZE * 3, NULL, 4, NULL);
//create task for controlling the stepper //create task for controlling the steppermotor (linear axis that guids the cable)
xTaskCreate(task_stepper_ctl, "task_stepper_ctl", configMINIMAL_STACK_SIZE * 3, NULL, 2, NULL); xTaskCreate(task_stepper_ctl, "task_stepper_ctl", configMINIMAL_STACK_SIZE * 3, NULL, 2, NULL);
#endif #endif