999 lines
33 KiB
C++
999 lines
33 KiB
C++
/*
|
|
TMC26XStepper.cpp - - TMC26X Stepper library for Wiring/Arduino
|
|
|
|
based on the stepper library by Tom Igoe, et. al.
|
|
|
|
Copyright (c) 2011, Interactive Matter, Marcus Nowotny
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
of this software and associated documentation files (the "Software"), to deal
|
|
in the Software without restriction, including without limitation the rights
|
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
copies of the Software, and to permit persons to whom the Software is
|
|
furnished to do so, subject to the following conditions:
|
|
|
|
The above copyright notice and this permission notice shall be included in
|
|
all copies or substantial portions of the Software.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
THE SOFTWARE.
|
|
|
|
*/
|
|
|
|
#if defined(ARDUINO) && ARDUINO >= 100
|
|
#include <Arduino.h>
|
|
#else
|
|
#include <WProgram.h>
|
|
#endif
|
|
#include <SPI.h>
|
|
#include "TMC26XStepper.h"
|
|
|
|
//some default values used in initialization
|
|
#define DEFAULT_MICROSTEPPING_VALUE 32
|
|
|
|
//TMC26X register definitions
|
|
#define DRIVER_CONTROL_REGISTER 0x0ul
|
|
#define CHOPPER_CONFIG_REGISTER 0x80000ul
|
|
#define COOL_STEP_REGISTER 0xA0000ul
|
|
#define STALL_GUARD2_LOAD_MEASURE_REGISTER 0xC0000ul
|
|
#define DRIVER_CONFIG_REGISTER 0xE0000ul
|
|
|
|
#define REGISTER_BIT_PATTERN 0xFFFFFul
|
|
|
|
//definitions for the driver control register
|
|
#define MICROSTEPPING_PATTERN 0xFul
|
|
#define STEP_INTERPOLATION 0x200ul
|
|
#define DOUBLE_EDGE_STEP 0x100ul
|
|
#define VSENSE 0x40ul
|
|
#define READ_MICROSTEP_POSTION 0x0ul
|
|
#define READ_STALL_GUARD_READING 0x10ul
|
|
#define READ_STALL_GUARD_AND_COOL_STEP 0x20ul
|
|
#define READ_SELECTION_PATTERN 0x30ul
|
|
|
|
//definitions for the chopper config register
|
|
#define CHOPPER_MODE_STANDARD 0x0ul
|
|
#define CHOPPER_MODE_T_OFF_FAST_DECAY 0x4000ul
|
|
#define T_OFF_PATTERN 0xful
|
|
#define RANDOM_TOFF_TIME 0x2000ul
|
|
#define BLANK_TIMING_PATTERN 0x18000ul
|
|
#define BLANK_TIMING_SHIFT 15
|
|
#define HYSTERESIS_DECREMENT_PATTERN 0x1800ul
|
|
#define HYSTERESIS_DECREMENT_SHIFT 11
|
|
#define HYSTERESIS_LOW_VALUE_PATTERN 0x780ul
|
|
#define HYSTERESIS_LOW_SHIFT 7
|
|
#define HYSTERESIS_START_VALUE_PATTERN 0x78ul
|
|
#define HYSTERESIS_START_VALUE_SHIFT 4
|
|
#define T_OFF_TIMING_PATERN 0xFul
|
|
|
|
//definitions for cool step register
|
|
#define MINIMUM_CURRENT_FOURTH 0x8000ul
|
|
#define CURRENT_DOWN_STEP_SPEED_PATTERN 0x6000ul
|
|
#define SE_MAX_PATTERN 0xF00ul
|
|
#define SE_CURRENT_STEP_WIDTH_PATTERN 0x60ul
|
|
#define SE_MIN_PATTERN 0xful
|
|
|
|
//definitions for stall guard2 current register
|
|
#define STALL_GUARD_FILTER_ENABLED 0x10000ul
|
|
#define STALL_GUARD_TRESHHOLD_VALUE_PATTERN 0x17F00ul
|
|
#define CURRENT_SCALING_PATTERN 0x1Ful
|
|
#define STALL_GUARD_CONFIG_PATTERN 0x17F00ul
|
|
#define STALL_GUARD_VALUE_PATTERN 0x7F00ul
|
|
|
|
//definitions for the input from the TCM260
|
|
#define STATUS_STALL_GUARD_STATUS 0x1ul
|
|
#define STATUS_OVER_TEMPERATURE_SHUTDOWN 0x2ul
|
|
#define STATUS_OVER_TEMPERATURE_WARNING 0x4ul
|
|
#define STATUS_SHORT_TO_GROUND_A 0x8ul
|
|
#define STATUS_SHORT_TO_GROUND_B 0x10ul
|
|
#define STATUS_OPEN_LOAD_A 0x20ul
|
|
#define STATUS_OPEN_LOAD_B 0x40ul
|
|
#define STATUS_STAND_STILL 0x80ul
|
|
#define READOUT_VALUE_PATTERN 0xFFC00ul
|
|
|
|
//default values
|
|
#define INITIAL_MICROSTEPPING 0x3ul //32th microstepping
|
|
|
|
//debuging output
|
|
//#define DEBUG
|
|
|
|
/*
|
|
* Constructor
|
|
* number_of_steps - the steps per rotation
|
|
* cs_pin - the SPI client select pin
|
|
* dir_pin - the pin where the direction pin is connected
|
|
* step_pin - the pin where the step pin is connected
|
|
*/
|
|
TMC26XStepper::TMC26XStepper(int number_of_steps, int cs_pin, int dir_pin, int step_pin, unsigned int current, unsigned int resistor)
|
|
{
|
|
//we are not started yet
|
|
started=false;
|
|
//by default cool step is not enabled
|
|
cool_step_enabled=false;
|
|
|
|
//save the pins for later use
|
|
this->cs_pin=cs_pin;
|
|
this->dir_pin=dir_pin;
|
|
this->step_pin = step_pin;
|
|
|
|
//store the current sense resistor value for later use
|
|
this->resistor = resistor;
|
|
|
|
//initizalize our status values
|
|
this->steps_left = 0;
|
|
this->direction = 0;
|
|
|
|
//initialize register values
|
|
driver_control_register_value=DRIVER_CONTROL_REGISTER | INITIAL_MICROSTEPPING;
|
|
chopper_config_register=CHOPPER_CONFIG_REGISTER;
|
|
|
|
//setting the default register values
|
|
driver_control_register_value=DRIVER_CONTROL_REGISTER|INITIAL_MICROSTEPPING;
|
|
microsteps = (1 << INITIAL_MICROSTEPPING);
|
|
chopper_config_register=CHOPPER_CONFIG_REGISTER;
|
|
cool_step_register_value=COOL_STEP_REGISTER;
|
|
stall_guard2_current_register_value=STALL_GUARD2_LOAD_MEASURE_REGISTER;
|
|
driver_configuration_register_value = DRIVER_CONFIG_REGISTER | READ_STALL_GUARD_READING;
|
|
|
|
//set the current
|
|
setCurrent(current);
|
|
//set to a conservative start value
|
|
setConstantOffTimeChopper(7, 54, 13,12,1);
|
|
//set a nice microstepping value
|
|
setMicrosteps(DEFAULT_MICROSTEPPING_VALUE);
|
|
//save the number of steps
|
|
this->number_of_steps = number_of_steps;
|
|
}
|
|
|
|
|
|
/*
|
|
* start & configure the stepper driver
|
|
* just must be called.
|
|
*/
|
|
void TMC26XStepper::start() {
|
|
|
|
#ifdef DEBUG
|
|
Serial.println("TMC26X stepper library");
|
|
Serial.print("CS pin: ");
|
|
Serial.println(cs_pin);
|
|
Serial.print("DIR pin: ");
|
|
Serial.println(dir_pin);
|
|
Serial.print("STEP pin: ");
|
|
Serial.println(step_pin);
|
|
Serial.print("current scaling: ");
|
|
Serial.println(current_scaling,DEC);
|
|
#endif
|
|
//set the pins as output & its initial value
|
|
pinMode(step_pin, OUTPUT);
|
|
pinMode(dir_pin, OUTPUT);
|
|
pinMode(cs_pin, OUTPUT);
|
|
digitalWrite(step_pin, LOW);
|
|
digitalWrite(dir_pin, LOW);
|
|
digitalWrite(cs_pin, HIGH);
|
|
|
|
//configure the SPI interface
|
|
SPI.setBitOrder(MSBFIRST);
|
|
SPI.setClockDivider(SPI_CLOCK_DIV8);
|
|
//todo this does not work reliably - find a way to foolprof set it (e.g. while communicating
|
|
//SPI.setDataMode(SPI_MODE3);
|
|
SPI.begin();
|
|
|
|
//set the initial values
|
|
send262(driver_control_register_value);
|
|
send262(chopper_config_register);
|
|
send262(cool_step_register_value);
|
|
send262(stall_guard2_current_register_value);
|
|
send262(driver_configuration_register_value);
|
|
|
|
//save that we are in running mode
|
|
started=true;
|
|
}
|
|
|
|
/*
|
|
Mark the driver as unstarted to be able to start it again
|
|
*/
|
|
void TMC26XStepper::un_start() {
|
|
started=false;
|
|
}
|
|
|
|
|
|
/*
|
|
Sets the speed in revs per minute
|
|
|
|
*/
|
|
void TMC26XStepper::setSpeed(unsigned int whatSpeed)
|
|
{
|
|
this->speed = whatSpeed;
|
|
this->step_delay = (60UL * 1000UL * 1000UL) / ((unsigned long)this->number_of_steps * (unsigned long)whatSpeed * (unsigned long)this->microsteps);
|
|
#ifdef DEBUG
|
|
Serial.print("Step delay in micros: ");
|
|
Serial.println(this->step_delay);
|
|
#endif
|
|
//update the next step time
|
|
this->next_step_time = this->last_step_time+this->step_delay;
|
|
|
|
}
|
|
|
|
unsigned int TMC26XStepper::getSpeed(void) {
|
|
return this->speed;
|
|
}
|
|
|
|
/*
|
|
Moves the motor steps_to_move steps. If the number is negative,
|
|
the motor moves in the reverse direction.
|
|
*/
|
|
char TMC26XStepper::step(int steps_to_move)
|
|
{
|
|
if (this->steps_left==0) {
|
|
this->steps_left = abs(steps_to_move); // how many steps to take
|
|
|
|
// determine direction based on whether steps_to_mode is + or -:
|
|
if (steps_to_move > 0) {
|
|
this->direction = 1;
|
|
} else if (steps_to_move < 0) {
|
|
this->direction = 0;
|
|
}
|
|
return 0;
|
|
} else {
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
char TMC26XStepper::move(void) {
|
|
// decrement the number of steps, moving one step each time:
|
|
if(this->steps_left>0) {
|
|
unsigned long time = micros();
|
|
// move only if the appropriate delay has passed:
|
|
if (time >= this->next_step_time) {
|
|
// increment or decrement the step number,
|
|
// depending on direction:
|
|
if (this->direction == 1) {
|
|
digitalWrite(step_pin, HIGH);
|
|
} else {
|
|
digitalWrite(dir_pin, HIGH);
|
|
digitalWrite(step_pin, HIGH);
|
|
}
|
|
// get the timeStamp of when you stepped:
|
|
this->last_step_time = time;
|
|
this->next_step_time = time+this->step_delay;
|
|
// decrement the steps left:
|
|
steps_left--;
|
|
//disable the step & dir pins
|
|
digitalWrite(step_pin, LOW);
|
|
digitalWrite(dir_pin, LOW);
|
|
}
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
char TMC26XStepper::isMoving(void) {
|
|
return (this->steps_left>0);
|
|
}
|
|
|
|
unsigned int TMC26XStepper::getStepsLeft(void) {
|
|
return this->steps_left;
|
|
}
|
|
|
|
char TMC26XStepper::stop(void) {
|
|
//note to self if the motor is currently moving
|
|
char state = isMoving();
|
|
//stop the motor
|
|
this->steps_left = 0;
|
|
this->direction = 0;
|
|
//return if it was moving
|
|
return state;
|
|
}
|
|
|
|
void TMC26XStepper::setCurrent(unsigned int current) {
|
|
unsigned char current_scaling = 0;
|
|
//calculate the current scaling from the max current setting (in mA)
|
|
double mASetting = (double)current;
|
|
double resistor_value = (double) this->resistor;
|
|
// remove vesense flag
|
|
this->driver_configuration_register_value &= ~(VSENSE);
|
|
//this is derrived from I=(cs+1)/32*(Vsense/Rsense)
|
|
//leading to cs = CS = 32*R*I/V (with V = 0,31V oder 0,165V and I = 1000*current)
|
|
//with Rsense=0,15
|
|
//for vsense = 0,310V (VSENSE not set)
|
|
//or vsense = 0,165V (VSENSE set)
|
|
current_scaling = (byte)((resistor_value*mASetting*32.0/(0.31*1000.0*1000.0))-0.5); //theoretically - 1.0 for better rounding it is 0.5
|
|
|
|
//check if the current scalingis too low
|
|
if (current_scaling<16) {
|
|
//set the csense bit to get a use half the sense voltage (to support lower motor currents)
|
|
this->driver_configuration_register_value |= VSENSE;
|
|
//and recalculate the current setting
|
|
current_scaling = (byte)((resistor_value*mASetting*32.0/(0.165*1000.0*1000.0))-0.5); //theoretically - 1.0 for better rounding it is 0.5
|
|
#ifdef DEBUG
|
|
Serial.print("CS (Vsense=1): ");
|
|
Serial.println(current_scaling);
|
|
} else {
|
|
Serial.print("CS: ");
|
|
Serial.println(current_scaling);
|
|
#endif
|
|
}
|
|
|
|
//do some sanity checks
|
|
if (current_scaling>31) {
|
|
current_scaling=31;
|
|
}
|
|
//delete the old value
|
|
stall_guard2_current_register_value &= ~(CURRENT_SCALING_PATTERN);
|
|
//set the new current scaling
|
|
stall_guard2_current_register_value |= current_scaling;
|
|
//if started we directly send it to the motor
|
|
if (started) {
|
|
send262(driver_configuration_register_value);
|
|
send262(stall_guard2_current_register_value);
|
|
}
|
|
}
|
|
|
|
unsigned int TMC26XStepper::getCurrent(void) {
|
|
//we calculate the current according to the datasheet to be on the safe side
|
|
//this is not the fastest but the most accurate and illustrative way
|
|
double result = (double)(stall_guard2_current_register_value & CURRENT_SCALING_PATTERN);
|
|
double resistor_value = (double)this->resistor;
|
|
double voltage = (driver_configuration_register_value & VSENSE)? 0.165:0.31;
|
|
result = (result+1.0)/32.0*voltage/resistor_value*1000.0*1000.0;
|
|
return (unsigned int)result;
|
|
}
|
|
|
|
void TMC26XStepper::setStallGuardThreshold(char stall_guard_threshold, char stall_guard_filter_enabled) {
|
|
if (stall_guard_threshold<-64) {
|
|
stall_guard_threshold = -64;
|
|
//We just have 5 bits
|
|
} else if (stall_guard_threshold > 63) {
|
|
stall_guard_threshold = 63;
|
|
}
|
|
//add trim down to 7 bits
|
|
stall_guard_threshold &=0x7f;
|
|
//delete old stall guard settings
|
|
stall_guard2_current_register_value &= ~(STALL_GUARD_CONFIG_PATTERN);
|
|
if (stall_guard_filter_enabled) {
|
|
stall_guard2_current_register_value |= STALL_GUARD_FILTER_ENABLED;
|
|
}
|
|
//Set the new stall guard threshold
|
|
stall_guard2_current_register_value |= (((unsigned long)stall_guard_threshold << 8) & STALL_GUARD_CONFIG_PATTERN);
|
|
//if started we directly send it to the motor
|
|
if (started) {
|
|
send262(stall_guard2_current_register_value);
|
|
}
|
|
}
|
|
|
|
char TMC26XStepper::getStallGuardThreshold(void) {
|
|
unsigned long stall_guard_threshold = stall_guard2_current_register_value & STALL_GUARD_VALUE_PATTERN;
|
|
//shift it down to bit 0
|
|
stall_guard_threshold >>=8;
|
|
//convert the value to an int to correctly handle the negative numbers
|
|
char result = stall_guard_threshold;
|
|
//check if it is negative and fill it up with leading 1 for proper negative number representation
|
|
if (result & _BV(6)) {
|
|
result |= 0xC0;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
char TMC26XStepper::getStallGuardFilter(void) {
|
|
if (stall_guard2_current_register_value & STALL_GUARD_FILTER_ENABLED) {
|
|
return -1;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
/*
|
|
* Set the number of microsteps per step.
|
|
* 0,2,4,8,16,32,64,128,256 is supported
|
|
* any value in between will be mapped to the next smaller value
|
|
* 0 and 1 set the motor in full step mode
|
|
*/
|
|
void TMC26XStepper::setMicrosteps(int number_of_steps) {
|
|
long setting_pattern;
|
|
//poor mans log
|
|
if (number_of_steps>=256) {
|
|
setting_pattern=0;
|
|
microsteps=256;
|
|
} else if (number_of_steps>=128) {
|
|
setting_pattern=1;
|
|
microsteps=128;
|
|
} else if (number_of_steps>=64) {
|
|
setting_pattern=2;
|
|
microsteps=64;
|
|
} else if (number_of_steps>=32) {
|
|
setting_pattern=3;
|
|
microsteps=32;
|
|
} else if (number_of_steps>=16) {
|
|
setting_pattern=4;
|
|
microsteps=16;
|
|
} else if (number_of_steps>=8) {
|
|
setting_pattern=5;
|
|
microsteps=8;
|
|
} else if (number_of_steps>=4) {
|
|
setting_pattern=6;
|
|
microsteps=4;
|
|
} else if (number_of_steps>=2) {
|
|
setting_pattern=7;
|
|
microsteps=2;
|
|
//1 and 0 lead to full step
|
|
} else if (number_of_steps<=1) {
|
|
setting_pattern=8;
|
|
microsteps=1;
|
|
}
|
|
#ifdef DEBUG
|
|
Serial.print("Microstepping: ");
|
|
Serial.println(microsteps);
|
|
#endif
|
|
//delete the old value
|
|
this->driver_control_register_value &=0xFFFF0ul;
|
|
//set the new value
|
|
this->driver_control_register_value |=setting_pattern;
|
|
|
|
//if started we directly send it to the motor
|
|
if (started) {
|
|
send262(driver_control_register_value);
|
|
}
|
|
//recalculate the stepping delay by simply setting the speed again
|
|
this->setSpeed(this->speed);
|
|
}
|
|
|
|
/*
|
|
* returns the effective number of microsteps at the moment
|
|
*/
|
|
int TMC26XStepper::getMicrosteps(void) {
|
|
return microsteps;
|
|
}
|
|
|
|
/*
|
|
* constant_off_time: The off time setting controls the minimum chopper frequency.
|
|
* For most applications an off time within the range of 5μs to 20μs will fit.
|
|
* 2...15: off time setting
|
|
*
|
|
* blank_time: Selects the comparator blank time. This time needs to safely cover the switching event and the
|
|
* duration of the ringing on the sense resistor. For
|
|
* 0: min. setting 3: max. setting
|
|
*
|
|
* fast_decay_time_setting: Fast decay time setting. With CHM=1, these bits control the portion of fast decay for each chopper cycle.
|
|
* 0: slow decay only
|
|
* 1...15: duration of fast decay phase
|
|
*
|
|
* sine_wave_offset: Sine wave offset. With CHM=1, these bits control the sine wave offset.
|
|
* A positive offset corrects for zero crossing error.
|
|
* -3..-1: negative offset 0: no offset 1...12: positive offset
|
|
*
|
|
* use_current_comparator: Selects usage of the current comparator for termination of the fast decay cycle.
|
|
* If current comparator is enabled, it terminates the fast decay cycle in case the current
|
|
* reaches a higher negative value than the actual positive value.
|
|
* 1: enable comparator termination of fast decay cycle
|
|
* 0: end by time only
|
|
*/
|
|
void TMC26XStepper::setConstantOffTimeChopper(char constant_off_time, char blank_time, char fast_decay_time_setting, char sine_wave_offset, unsigned char use_current_comparator) {
|
|
//perform some sanity checks
|
|
if (constant_off_time<2) {
|
|
constant_off_time=2;
|
|
} else if (constant_off_time>15) {
|
|
constant_off_time=15;
|
|
}
|
|
//save the constant off time
|
|
this->constant_off_time = constant_off_time;
|
|
char blank_value;
|
|
//calculate the value acc to the clock cycles
|
|
if (blank_time>=54) {
|
|
blank_value=3;
|
|
} else if (blank_time>=36) {
|
|
blank_value=2;
|
|
} else if (blank_time>=24) {
|
|
blank_value=1;
|
|
} else {
|
|
blank_value=0;
|
|
}
|
|
if (fast_decay_time_setting<0) {
|
|
fast_decay_time_setting=0;
|
|
} else if (fast_decay_time_setting>15) {
|
|
fast_decay_time_setting=15;
|
|
}
|
|
if (sine_wave_offset < -3) {
|
|
sine_wave_offset = -3;
|
|
} else if (sine_wave_offset>12) {
|
|
sine_wave_offset = 12;
|
|
}
|
|
//shift the sine_wave_offset
|
|
sine_wave_offset +=3;
|
|
|
|
//calculate the register setting
|
|
//first of all delete all the values for this
|
|
chopper_config_register &= ~((1<<12) | BLANK_TIMING_PATTERN | HYSTERESIS_DECREMENT_PATTERN | HYSTERESIS_LOW_VALUE_PATTERN | HYSTERESIS_START_VALUE_PATTERN | T_OFF_TIMING_PATERN);
|
|
//set the constant off pattern
|
|
chopper_config_register |= CHOPPER_MODE_T_OFF_FAST_DECAY;
|
|
//set the blank timing value
|
|
chopper_config_register |= ((unsigned long)blank_value) << BLANK_TIMING_SHIFT;
|
|
//setting the constant off time
|
|
chopper_config_register |= constant_off_time;
|
|
//set the fast decay time
|
|
//set msb
|
|
chopper_config_register |= (((unsigned long)(fast_decay_time_setting & 0x8))<<HYSTERESIS_DECREMENT_SHIFT);
|
|
//other bits
|
|
chopper_config_register |= (((unsigned long)(fast_decay_time_setting & 0x7))<<HYSTERESIS_START_VALUE_SHIFT);
|
|
//set the sine wave offset
|
|
chopper_config_register |= (unsigned long)sine_wave_offset << HYSTERESIS_LOW_SHIFT;
|
|
//using the current comparator?
|
|
if (!use_current_comparator) {
|
|
chopper_config_register |= (1<<12);
|
|
}
|
|
//if started we directly send it to the motor
|
|
if (started) {
|
|
send262(driver_control_register_value);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* constant_off_time: The off time setting controls the minimum chopper frequency.
|
|
* For most applications an off time within the range of 5μs to 20μs will fit.
|
|
* 2...15: off time setting
|
|
*
|
|
* blank_time: Selects the comparator blank time. This time needs to safely cover the switching event and the
|
|
* duration of the ringing on the sense resistor. For
|
|
* 0: min. setting 3: max. setting
|
|
*
|
|
* hysteresis_start: Hysteresis start setting. Please remark, that this value is an offset to the hysteresis end value HEND.
|
|
* 1...8
|
|
*
|
|
* hysteresis_end: Hysteresis end setting. Sets the hysteresis end value after a number of decrements. Decrement interval time is controlled by HDEC.
|
|
* The sum HSTRT+HEND must be <16. At a current setting CS of max. 30 (amplitude reduced to 240), the sum is not limited.
|
|
* -3..-1: negative HEND 0: zero HEND 1...12: positive HEND
|
|
*
|
|
* hysteresis_decrement: Hysteresis decrement setting. This setting determines the slope of the hysteresis during on time and during fast decay time.
|
|
* 0: fast decrement 3: very slow decrement
|
|
*/
|
|
|
|
void TMC26XStepper::setSpreadCycleChopper(char constant_off_time, char blank_time, char hysteresis_start, char hysteresis_end, char hysteresis_decrement) {
|
|
//perform some sanity checks
|
|
if (constant_off_time<2) {
|
|
constant_off_time=2;
|
|
} else if (constant_off_time>15) {
|
|
constant_off_time=15;
|
|
}
|
|
//save the constant off time
|
|
this->constant_off_time = constant_off_time;
|
|
char blank_value;
|
|
//calculate the value acc to the clock cycles
|
|
if (blank_time>=54) {
|
|
blank_value=3;
|
|
} else if (blank_time>=36) {
|
|
blank_value=2;
|
|
} else if (blank_time>=24) {
|
|
blank_value=1;
|
|
} else {
|
|
blank_value=0;
|
|
}
|
|
if (hysteresis_start<1) {
|
|
hysteresis_start=1;
|
|
} else if (hysteresis_start>8) {
|
|
hysteresis_start=8;
|
|
}
|
|
hysteresis_start--;
|
|
|
|
if (hysteresis_end < -3) {
|
|
hysteresis_end = -3;
|
|
} else if (hysteresis_end>12) {
|
|
hysteresis_end = 12;
|
|
}
|
|
//shift the hysteresis_end
|
|
hysteresis_end +=3;
|
|
|
|
if (hysteresis_decrement<0) {
|
|
hysteresis_decrement=0;
|
|
} else if (hysteresis_decrement>3) {
|
|
hysteresis_decrement=3;
|
|
}
|
|
|
|
//first of all delete all the values for this
|
|
chopper_config_register &= ~(CHOPPER_MODE_T_OFF_FAST_DECAY | BLANK_TIMING_PATTERN | HYSTERESIS_DECREMENT_PATTERN | HYSTERESIS_LOW_VALUE_PATTERN | HYSTERESIS_START_VALUE_PATTERN | T_OFF_TIMING_PATERN);
|
|
|
|
//set the blank timing value
|
|
chopper_config_register |= ((unsigned long)blank_value) << BLANK_TIMING_SHIFT;
|
|
//setting the constant off time
|
|
chopper_config_register |= constant_off_time;
|
|
//set the hysteresis_start
|
|
chopper_config_register |= ((unsigned long)hysteresis_start) << HYSTERESIS_START_VALUE_SHIFT;
|
|
//set the hysteresis end
|
|
chopper_config_register |= ((unsigned long)hysteresis_end) << HYSTERESIS_LOW_SHIFT;
|
|
//set the hystereis decrement
|
|
chopper_config_register |= ((unsigned long)blank_value) << BLANK_TIMING_SHIFT;
|
|
//if started we directly send it to the motor
|
|
if (started) {
|
|
send262(driver_control_register_value);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* In a constant off time chopper scheme both coil choppers run freely, i.e. are not synchronized.
|
|
* The frequency of each chopper mainly depends on the coil current and the position dependant motor coil inductivity, thus it depends on the microstep position.
|
|
* With some motors a slightly audible beat can occur between the chopper frequencies, especially when they are near to each other. This typically occurs at a
|
|
* few microstep positions within each quarter wave. This effect normally is not audible when compared to mechanical noise generated by ball bearings, etc.
|
|
* Further factors which can cause a similar effect are a poor layout of sense resistor GND connection.
|
|
* Hint: A common factor, which can cause motor noise, is a bad PCB layout causing coupling of both sense resistor voltages
|
|
* (please refer to sense resistor layout hint in chapter 8.1).
|
|
* In order to minimize the effect of a beat between both chopper frequencies, an internal random generator is provided.
|
|
* It modulates the slow decay time setting when switched on by the RNDTF bit. The RNDTF feature further spreads the chopper spectrum,
|
|
* reducing electromagnetic emission on single frequencies.
|
|
*/
|
|
void TMC26XStepper::setRandomOffTime(char value) {
|
|
if (value) {
|
|
chopper_config_register |= RANDOM_TOFF_TIME;
|
|
} else {
|
|
chopper_config_register &= ~(RANDOM_TOFF_TIME);
|
|
}
|
|
//if started we directly send it to the motor
|
|
if (started) {
|
|
send262(driver_control_register_value);
|
|
}
|
|
}
|
|
|
|
void TMC26XStepper::setCoolStepConfiguration(unsigned int lower_SG_threshold, unsigned int SG_hysteresis, unsigned char current_decrement_step_size,
|
|
unsigned char current_increment_step_size, unsigned char lower_current_limit) {
|
|
//sanitize the input values
|
|
if (lower_SG_threshold>480) {
|
|
lower_SG_threshold = 480;
|
|
}
|
|
//divide by 32
|
|
lower_SG_threshold >>=5;
|
|
if (SG_hysteresis>480) {
|
|
SG_hysteresis=480;
|
|
}
|
|
//divide by 32
|
|
SG_hysteresis >>=5;
|
|
if (current_decrement_step_size>3) {
|
|
current_decrement_step_size=3;
|
|
}
|
|
if (current_increment_step_size>3) {
|
|
current_increment_step_size=3;
|
|
}
|
|
if (lower_current_limit>1) {
|
|
lower_current_limit=1;
|
|
}
|
|
//store the lower level in order to enable/disable the cool step
|
|
this->cool_step_lower_threshold=lower_SG_threshold;
|
|
//if cool step is not enabled we delete the lower value to keep it disabled
|
|
if (!this->cool_step_enabled) {
|
|
lower_SG_threshold=0;
|
|
}
|
|
//the good news is that we can start with a complete new cool step register value
|
|
//and simply set the values in the register
|
|
cool_step_register_value = ((unsigned long)lower_SG_threshold) | (((unsigned long)SG_hysteresis)<<8) | (((unsigned long)current_decrement_step_size)<<5)
|
|
| (((unsigned long)current_increment_step_size)<<13) | (((unsigned long)lower_current_limit)<<15)
|
|
//and of course we have to include the signature of the register
|
|
| COOL_STEP_REGISTER;
|
|
//Serial.println(cool_step_register_value,HEX);
|
|
if (started) {
|
|
send262(cool_step_register_value);
|
|
}
|
|
}
|
|
|
|
void TMC26XStepper::setCoolStepEnabled(boolean enabled) {
|
|
//simply delete the lower limit to disable the cool step
|
|
cool_step_register_value &= ~SE_MIN_PATTERN;
|
|
//and set it to the proper value if cool step is to be enabled
|
|
if (enabled) {
|
|
cool_step_register_value |=this->cool_step_lower_threshold;
|
|
}
|
|
//and save the enabled status
|
|
this->cool_step_enabled = enabled;
|
|
//save the register value
|
|
if (started) {
|
|
send262(cool_step_register_value);
|
|
}
|
|
}
|
|
|
|
boolean TMC26XStepper::isCoolStepEnabled(void) {
|
|
return this->cool_step_enabled;
|
|
}
|
|
|
|
unsigned int TMC26XStepper::getCoolStepLowerSgThreshold() {
|
|
//we return our internally stored value - in order to provide the correct setting even if cool step is not enabled
|
|
return this->cool_step_lower_threshold<<5;
|
|
}
|
|
|
|
unsigned int TMC26XStepper::getCoolStepUpperSgThreshold() {
|
|
return (unsigned char)((cool_step_register_value & SE_MAX_PATTERN)>>8)<<5;
|
|
}
|
|
|
|
unsigned char TMC26XStepper::getCoolStepCurrentIncrementSize() {
|
|
return (unsigned char)((cool_step_register_value & CURRENT_DOWN_STEP_SPEED_PATTERN)>>13);
|
|
}
|
|
|
|
unsigned char TMC26XStepper::getCoolStepNumberOfSGReadings() {
|
|
return (unsigned char)((cool_step_register_value & SE_CURRENT_STEP_WIDTH_PATTERN)>>5);
|
|
}
|
|
|
|
unsigned char TMC26XStepper::getCoolStepLowerCurrentLimit() {
|
|
return (unsigned char)((cool_step_register_value & MINIMUM_CURRENT_FOURTH)>>15);
|
|
}
|
|
|
|
void TMC26XStepper::setEnabled(boolean enabled) {
|
|
//delete the t_off in the chopper config to get sure
|
|
chopper_config_register &= ~(T_OFF_PATTERN);
|
|
if (enabled) {
|
|
//and set the t_off time
|
|
chopper_config_register |= this->constant_off_time;
|
|
}
|
|
//if not enabled we don't have to do anything since we already delete t_off from the register
|
|
if (started) {
|
|
send262(chopper_config_register);
|
|
}
|
|
}
|
|
|
|
boolean TMC26XStepper::isEnabled() {
|
|
if (chopper_config_register & T_OFF_PATTERN) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* reads a value from the TMC26X status register. The value is not obtained directly but can then
|
|
* be read by the various status routines.
|
|
*
|
|
*/
|
|
void TMC26XStepper::readStatus(char read_value) {
|
|
unsigned long old_driver_configuration_register_value = driver_configuration_register_value;
|
|
//reset the readout configuration
|
|
driver_configuration_register_value &= ~(READ_SELECTION_PATTERN);
|
|
//this now equals TMC26X_READOUT_POSITION - so we just have to check the other two options
|
|
if (read_value == TMC26X_READOUT_STALLGUARD) {
|
|
driver_configuration_register_value |= READ_STALL_GUARD_READING;
|
|
} else if (read_value == TMC26X_READOUT_CURRENT) {
|
|
driver_configuration_register_value |= READ_STALL_GUARD_AND_COOL_STEP;
|
|
}
|
|
//all other cases are ignored to prevent funny values
|
|
//check if the readout is configured for the value we are interested in
|
|
if (driver_configuration_register_value!=old_driver_configuration_register_value) {
|
|
//because then we need to write the value twice - one time for configuring, second time to get the value, see below
|
|
send262(driver_configuration_register_value);
|
|
}
|
|
//write the configuration to get the last status
|
|
send262(driver_configuration_register_value);
|
|
}
|
|
|
|
int TMC26XStepper::getMotorPosition(void) {
|
|
//we read it out even if we are not started yet - perhaps it is useful information for somebody
|
|
readStatus(TMC26X_READOUT_POSITION);
|
|
return getReadoutValue();
|
|
}
|
|
|
|
//reads the stall guard setting from last status
|
|
//returns -1 if stallguard information is not present
|
|
int TMC26XStepper::getCurrentStallGuardReading(void) {
|
|
//if we don't yet started there cannot be a stall guard value
|
|
if (!started) {
|
|
return -1;
|
|
}
|
|
//not time optimal, but solution optiomal:
|
|
//first read out the stall guard value
|
|
readStatus(TMC26X_READOUT_STALLGUARD);
|
|
return getReadoutValue();
|
|
}
|
|
|
|
unsigned char TMC26XStepper::getCurrentCSReading(void) {
|
|
//if we don't yet started there cannot be a stall guard value
|
|
if (!started) {
|
|
return 0;
|
|
}
|
|
//not time optimal, but solution optiomal:
|
|
//first read out the stall guard value
|
|
readStatus(TMC26X_READOUT_CURRENT);
|
|
return (getReadoutValue() & 0x1f);
|
|
}
|
|
|
|
unsigned int TMC26XStepper::getCurrentCurrent(void) {
|
|
double result = (double)getCurrentCSReading();
|
|
double resistor_value = (double)this->resistor;
|
|
double voltage = (driver_configuration_register_value & VSENSE)? 0.165:0.31;
|
|
result = (result+1.0)/32.0*voltage/resistor_value*1000.0*1000.0;
|
|
return (unsigned int)result;
|
|
}
|
|
|
|
/*
|
|
return true if the stallguard threshold has been reached
|
|
*/
|
|
boolean TMC26XStepper::isStallGuardOverThreshold(void) {
|
|
if (!this->started) {
|
|
return false;
|
|
}
|
|
return (driver_status_result & STATUS_STALL_GUARD_STATUS);
|
|
}
|
|
|
|
/*
|
|
returns if there is any over temperature condition:
|
|
OVER_TEMPERATURE_PREWARING if pre warning level has been reached
|
|
OVER_TEMPERATURE_SHUTDOWN if the temperature is so hot that the driver is shut down
|
|
Any of those levels are not too good.
|
|
*/
|
|
char TMC26XStepper::getOverTemperature(void) {
|
|
if (!this->started) {
|
|
return 0;
|
|
}
|
|
if (driver_status_result & STATUS_OVER_TEMPERATURE_SHUTDOWN) {
|
|
return TMC26X_OVERTEMPERATURE_SHUTDOWN;
|
|
}
|
|
if (driver_status_result & STATUS_OVER_TEMPERATURE_WARNING) {
|
|
return TMC26X_OVERTEMPERATURE_PREWARING;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//is motor channel A shorted to ground
|
|
boolean TMC26XStepper::isShortToGroundA(void) {
|
|
if (!this->started) {
|
|
return false;
|
|
}
|
|
return (driver_status_result & STATUS_SHORT_TO_GROUND_A);
|
|
}
|
|
|
|
//is motor channel B shorted to ground
|
|
boolean TMC26XStepper::isShortToGroundB(void) {
|
|
if (!this->started) {
|
|
return false;
|
|
}
|
|
return (driver_status_result & STATUS_SHORT_TO_GROUND_B);
|
|
}
|
|
|
|
//is motor channel A connected
|
|
boolean TMC26XStepper::isOpenLoadA(void) {
|
|
if (!this->started) {
|
|
return false;
|
|
}
|
|
return (driver_status_result & STATUS_OPEN_LOAD_A);
|
|
}
|
|
|
|
//is motor channel B connected
|
|
boolean TMC26XStepper::isOpenLoadB(void) {
|
|
if (!this->started) {
|
|
return false;
|
|
}
|
|
return (driver_status_result & STATUS_OPEN_LOAD_B);
|
|
}
|
|
|
|
//is chopper inactive since 2^20 clock cycles - defaults to ~0,08s
|
|
boolean TMC26XStepper::isStandStill(void) {
|
|
if (!this->started) {
|
|
return false;
|
|
}
|
|
return (driver_status_result & STATUS_STAND_STILL);
|
|
}
|
|
|
|
//is chopper inactive since 2^20 clock cycles - defaults to ~0,08s
|
|
boolean TMC26XStepper::isStallGuardReached(void) {
|
|
if (!this->started) {
|
|
return false;
|
|
}
|
|
return (driver_status_result & STATUS_STALL_GUARD_STATUS);
|
|
}
|
|
|
|
//reads the stall guard setting from last status
|
|
//returns -1 if stallguard inforamtion is not present
|
|
int TMC26XStepper::getReadoutValue(void) {
|
|
return (int)(driver_status_result >> 10);
|
|
}
|
|
|
|
int TMC26XStepper::getResistor() {
|
|
return this->resistor;
|
|
}
|
|
|
|
boolean TMC26XStepper::isCurrentScalingHalfed() {
|
|
if (this->driver_configuration_register_value & VSENSE) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
/*
|
|
version() returns the version of the library:
|
|
*/
|
|
int TMC26XStepper::version(void)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
void TMC26XStepper::debugLastStatus() {
|
|
#ifdef DEBUG
|
|
if (this->started) {
|
|
if (this->getOverTemperature()&TMC26X_OVERTEMPERATURE_PREWARING) {
|
|
Serial.println("WARNING: Overtemperature Prewarning!");
|
|
} else if (this->getOverTemperature()&TMC26X_OVERTEMPERATURE_SHUTDOWN) {
|
|
Serial.println("ERROR: Overtemperature Shutdown!");
|
|
}
|
|
if (this->isShortToGroundA()) {
|
|
Serial.println("ERROR: SHORT to ground on channel A!");
|
|
}
|
|
if (this->isShortToGroundB()) {
|
|
Serial.println("ERROR: SHORT to ground on channel A!");
|
|
}
|
|
if (this->isOpenLoadA()) {
|
|
Serial.println("ERROR: Channel A seems to be unconnected!");
|
|
}
|
|
if (this->isOpenLoadB()) {
|
|
Serial.println("ERROR: Channel B seems to be unconnected!");
|
|
}
|
|
if (this->isStallGuardReached()) {
|
|
Serial.println("INFO: Stall Guard level reached!");
|
|
}
|
|
if (this->isStandStill()) {
|
|
Serial.println("INFO: Motor is standing still.");
|
|
}
|
|
unsigned long readout_config = driver_configuration_register_value & READ_SELECTION_PATTERN;
|
|
int value = getReadoutValue();
|
|
if (readout_config == READ_MICROSTEP_POSTION) {
|
|
Serial.print("Microstep postion phase A: ");
|
|
Serial.println(value);
|
|
} else if (readout_config == READ_STALL_GUARD_READING) {
|
|
Serial.print("Stall Guard value:");
|
|
Serial.println(value);
|
|
} else if (readout_config == READ_STALL_GUARD_AND_COOL_STEP) {
|
|
int stallGuard = value & 0xf;
|
|
int current = value & 0x1F0;
|
|
Serial.print("Approx Stall Guard: ");
|
|
Serial.println(stallGuard);
|
|
Serial.print("Current level");
|
|
Serial.println(current);
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
* send register settings to the stepper driver via SPI
|
|
* returns the current status
|
|
*/
|
|
inline void TMC26XStepper::send262(unsigned long datagram) {
|
|
unsigned long i_datagram;
|
|
|
|
//preserver the previous spi mode
|
|
unsigned char oldMode = SPCR & SPI_MODE_MASK;
|
|
|
|
//if the mode is not correct set it to mode 3
|
|
if (oldMode != SPI_MODE3) {
|
|
SPI.setDataMode(SPI_MODE3);
|
|
}
|
|
|
|
//select the TMC driver
|
|
digitalWrite(cs_pin,LOW);
|
|
|
|
//ensure that only valid bist are set (0-19)
|
|
//datagram &=REGISTER_BIT_PATTERN;
|
|
|
|
#ifdef DEBUG
|
|
Serial.print("Sending ");
|
|
Serial.println(datagram,HEX);
|
|
#endif
|
|
|
|
//write/read the values
|
|
i_datagram = SPI.transfer((datagram >> 16) & 0xff);
|
|
i_datagram <<= 8;
|
|
i_datagram |= SPI.transfer((datagram >> 8) & 0xff);
|
|
i_datagram <<= 8;
|
|
i_datagram |= SPI.transfer((datagram) & 0xff);
|
|
i_datagram >>= 4;
|
|
|
|
#ifdef DEBUG
|
|
Serial.print("Received ");
|
|
Serial.println(i_datagram,HEX);
|
|
debugLastStatus();
|
|
#endif
|
|
//deselect the TMC chip
|
|
digitalWrite(cs_pin,HIGH);
|
|
|
|
//restore the previous SPI mode if neccessary
|
|
//if the mode is not correct set it to mode 3
|
|
if (oldMode != SPI_MODE3) {
|
|
SPI.setDataMode(oldMode);
|
|
}
|
|
|
|
|
|
//store the datagram as status result
|
|
driver_status_result = i_datagram;
|
|
} |