andrey
/
Marlin_FB4S
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

Tweak STM32F7 TMC2660 class

pull/1/head
Scott Lahteine 6 years ago
parent
a0a3b23e35
commit
b682a1961a
2 changed files with 137 additions and 139 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 180
      Marlin/src/HAL/HAL_STM32F7/TMC2660.cpp
  2. 96
      Marlin/src/HAL/HAL_STM32F7/TMC2660.h

180
Marlin/src/HAL/HAL_STM32F7/TMC2660.cpp
View File

@ -87,7 +87,7 @@
#define SE_CURRENT_STEP_WIDTH_PATTERN 0x60ul
#define SE_MIN_PATTERN 0xFul
//definitions for stall guard2 current register
//definitions for StallGuard2 current register
#define STALL_GUARD_FILTER_ENABLED 0x10000ul
#define STALL_GUARD_TRESHHOLD_VALUE_PATTERN 0x17F00ul
#define CURRENT_SCALING_PATTERN 0x1Ful
@ -118,7 +118,7 @@ SPIClass SPI_6(SPI6, SPI6_MOSI_PIN, SPI6_MISO_PIN, SPI6_SCK_PIN);
//#define TMC_DEBUG1
unsigned char current_scaling = 0;
uint8_t current_scaling = 0;
/**
* Constructor
@ -127,7 +127,7 @@ unsigned char current_scaling = 0;
* 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) {
TMC26XStepper::TMC26XStepper(int16_t number_of_steps, int16_t cs_pin, int16_t dir_pin, int16_t step_pin, uint16_t current, uint16_t resistor) {
// We are not started yet
started = false;
@ -155,7 +155,7 @@ TMC26XStepper::TMC26XStepper(int number_of_steps, int cs_pin, int dir_pin, int s
microsteps = _BV(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;
stallguard2_current_register_value = STALL_GUARD2_LOAD_MEASURE_REGISTER;
driver_configuration_register_value = DRIVER_CONFIG_REGISTER | READ_STALL_GUARD_READING;
// Set the current
@ -202,7 +202,7 @@ void TMC26XStepper::start() {
send262(driver_control_register_value);
send262(chopper_config_register);
send262(cool_step_register_value);
send262(stall_guard2_current_register_value);
send262(stallguard2_current_register_value);
send262(driver_configuration_register_value);
//save that we are in running mode
@ -218,9 +218,9 @@ void TMC26XStepper::un_start() { started = false; }
/**
* Sets the speed in revs per minute
*/
void TMC26XStepper::setSpeed(unsigned int whatSpeed) {
void TMC26XStepper::setSpeed(uint16_t whatSpeed) {
this->speed = whatSpeed;
this->step_delay = 60UL * sq(1000UL) / ((unsigned long)this->number_of_steps * (unsigned long)whatSpeed * (unsigned long)this->microsteps);
this->step_delay = 60UL * sq(1000UL) / ((uint32_t)this->number_of_steps * (uint32_t)whatSpeed * (uint32_t)this->microsteps);
#ifdef TMC_DEBUG0 // crashes
//SERIAL_PRINTF("Step delay in micros: ");
SERIAL_ECHOPAIR("\nStep delay in micros: ", this->step_delay);
@ -229,13 +229,13 @@ void TMC26XStepper::setSpeed(unsigned int whatSpeed) {
this->next_step_time = this->last_step_time + this->step_delay;
}
unsigned int TMC26XStepper::getSpeed(void) { return this->speed; }
uint16_t TMC26XStepper::getSpeed(void) { return this->speed; }
/**
* Moves the motor steps_to_move steps.
* Negative indicates the reverse direction.
*/
char TMC26XStepper::step(int steps_to_move) {
char TMC26XStepper::step(int16_t steps_to_move) {
if (this->steps_left == 0) {
this->steps_left = ABS(steps_to_move); // how many steps to take
@ -252,7 +252,7 @@ char TMC26XStepper::step(int steps_to_move) {
char TMC26XStepper::move(void) {
// decrement the number of steps, moving one step each time:
if (this->steps_left > 0) {
unsigned long time = micros();
uint32_t time = micros();
// move only if the appropriate delay has passed:
// rem if (time >= this->next_step_time) {
@ -282,7 +282,7 @@ char TMC26XStepper::move(void) {
char TMC26XStepper::isMoving(void) { return this->steps_left > 0; }
unsigned int TMC26XStepper::getStepsLeft(void) { return this->steps_left; }
uint16_t TMC26XStepper::getStepsLeft(void) { return this->steps_left; }
char TMC26XStepper::stop(void) {
//note to self if the motor is currently moving
@ -294,8 +294,8 @@ char TMC26XStepper::stop(void) {
return state;
}
void TMC26XStepper::setCurrent(unsigned int current) {
unsigned char current_scaling = 0;
void TMC26XStepper::setCurrent(uint16_t current) {
uint8_t current_scaling = 0;
//calculate the current scaling from the max current setting (in mA)
float mASetting = (float)current,
resistor_value = (float)this->resistor;
@ -327,49 +327,49 @@ void TMC26XStepper::setCurrent(unsigned int current) {
NOMORE(current_scaling, 31);
// delete the old value
stall_guard2_current_register_value &= ~(CURRENT_SCALING_PATTERN);
stallguard2_current_register_value &= ~(CURRENT_SCALING_PATTERN);
// set the new current scaling
stall_guard2_current_register_value |= current_scaling;
stallguard2_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);
send262(stallguard2_current_register_value);
}
}
unsigned int TMC26XStepper::getCurrent(void) {
uint16_t TMC26XStepper::getCurrent(void) {
// 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.
float result = (float)(stall_guard2_current_register_value & CURRENT_SCALING_PATTERN),
float result = (float)(stallguard2_current_register_value & CURRENT_SCALING_PATTERN),
resistor_value = (float)this->resistor,
voltage = (driver_configuration_register_value & VSENSE) ? 0.165 : 0.31;
result = (result + 1.0) / 32.0 * voltage / resistor_value * sq(1000.0);
return (unsigned int)result;
return (uint16_t)result;
}
void TMC26XStepper::setStallGuardThreshold(char stall_guard_threshold, char stall_guard_filter_enabled) {
void TMC26XStepper::setStallGuardThreshold(char stallguard_threshold, char stallguard_filter_enabled) {
// We just have 5 bits
LIMIT(stall_guard_threshold, -64, 63);
LIMIT(stallguard_threshold, -64, 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);
stallguard_threshold &= 0x7F;
// Delete old StallGuard settings
stallguard2_current_register_value &= ~(STALL_GUARD_CONFIG_PATTERN);
if (stallguard_filter_enabled)
stallguard2_current_register_value |= STALL_GUARD_FILTER_ENABLED;
// Set the new StallGuard threshold
stallguard2_current_register_value |= (((uint32_t)stallguard_threshold << 8) & STALL_GUARD_CONFIG_PATTERN);
// If started we directly send it to the motor
if (started) send262(stall_guard2_current_register_value);
if (started) send262(stallguard2_current_register_value);
}
char TMC26XStepper::getStallGuardThreshold(void) {
unsigned long stall_guard_threshold = stall_guard2_current_register_value & STALL_GUARD_VALUE_PATTERN;
uint32_t stallguard_threshold = stallguard2_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;
stallguard_threshold >>= 8;
//convert the value to an int16_t to correctly handle the negative numbers
char result = stallguard_threshold;
//check if it is negative and fill it up with leading 1 for proper negative number representation
//rem if (result & _BV(6)) {
@ -378,7 +378,7 @@ char TMC26XStepper::getStallGuardThreshold(void) {
}
char TMC26XStepper::getStallGuardFilter(void) {
if (stall_guard2_current_register_value & STALL_GUARD_FILTER_ENABLED)
if (stallguard2_current_register_value & STALL_GUARD_FILTER_ENABLED)
return -1;
return 0;
}
@ -389,7 +389,7 @@ char TMC26XStepper::getStallGuardFilter(void) {
* 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) {
void TMC26XStepper::setMicrosteps(int16_t number_of_steps) {
long setting_pattern;
//poor mans log
if (number_of_steps >= 256) {
@ -448,7 +448,7 @@ void TMC26XStepper::setMicrosteps(int number_of_steps) {
/**
* returns the effective number of microsteps at the moment
*/
int TMC26XStepper::getMicrosteps(void) { return microsteps; }
int16_t TMC26XStepper::getMicrosteps(void) { return microsteps; }
/**
* constant_off_time: The off time setting controls the minimum chopper frequency.
@ -473,7 +473,7 @@ int TMC26XStepper::getMicrosteps(void) { return microsteps; }
* 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) {
void TMC26XStepper::setConstantOffTimeChopper(char constant_off_time, char blank_time, char fast_decay_time_setting, char sine_wave_offset, uint8_t use_current_comparator) {
// Perform some sanity checks
LIMIT(constant_off_time, 2, 15);
@ -497,16 +497,16 @@ void TMC26XStepper::setConstantOffTimeChopper(char constant_off_time, char blank
// 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;
chopper_config_register |= ((uint32_t)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);
chopper_config_register |= (((uint32_t)(fast_decay_time_setting & 0x8)) << HYSTERESIS_DECREMENT_SHIFT);
// Other bits
chopper_config_register |= (((unsigned long)(fast_decay_time_setting & 0x7)) << HYSTERESIS_START_VALUE_SHIFT);
chopper_config_register |= (((uint32_t)(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;
chopper_config_register |= (uint32_t)sine_wave_offset << HYSTERESIS_LOW_SHIFT;
// Using the current comparator?
if (!use_current_comparator)
chopper_config_register |= _BV(12);
@ -564,15 +564,15 @@ void TMC26XStepper::setSpreadCycleChopper(char constant_off_time, char blank_tim
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;
chopper_config_register |= ((uint32_t)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;
chopper_config_register |= ((uint32_t)hysteresis_start) << HYSTERESIS_START_VALUE_SHIFT;
//set the hysteresis end
chopper_config_register |= ((unsigned long)hysteresis_end) << HYSTERESIS_LOW_SHIFT;
chopper_config_register |= ((uint32_t)hysteresis_end) << HYSTERESIS_LOW_SHIFT;
//set the hystereis decrement
chopper_config_register |= ((unsigned long)blank_value) << BLANK_TIMING_SHIFT;
chopper_config_register |= ((uint32_t)blank_value) << BLANK_TIMING_SHIFT;
//if started we directly send it to the motor
if (started) {
//rem send262(driver_control_register_value);
@ -605,12 +605,12 @@ void TMC26XStepper::setRandomOffTime(char 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)
{
uint16_t lower_SG_threshold,
uint16_t SG_hysteresis,
uint8_t current_decrement_step_size,
uint8_t current_increment_step_size,
uint8_t lower_current_limit
) {
// Sanitize the input values
NOMORE(lower_SG_threshold, 480);
// Divide by 32
@ -628,11 +628,11 @@ void TMC26XStepper::setCoolStepConfiguration(
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)
cool_step_register_value = ((uint32_t)lower_SG_threshold)
| (((uint32_t)SG_hysteresis) << 8)
| (((uint32_t)current_decrement_step_size) << 5)
| (((uint32_t)current_increment_step_size) << 13)
| (((uint32_t)lower_current_limit) << 15)
| COOL_STEP_REGISTER; // Register signature
//SERIAL_PRINTFln(cool_step_register_value,HEX);
@ -653,25 +653,25 @@ void TMC26XStepper::setCoolStepEnabled(boolean enabled) {
boolean TMC26XStepper::isCoolStepEnabled(void) { return this->cool_step_enabled; }
unsigned int TMC26XStepper::getCoolStepLowerSgThreshold() {
uint16_t 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;
uint16_t TMC26XStepper::getCoolStepUpperSgThreshold() {
return (uint8_t)((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);
uint8_t TMC26XStepper::getCoolStepCurrentIncrementSize() {
return (uint8_t)((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);
uint8_t TMC26XStepper::getCoolStepNumberOfSGReadings() {
return (uint8_t)((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);
uint8_t TMC26XStepper::getCoolStepLowerCurrentLimit() {
return (uint8_t)((cool_step_register_value & MINIMUM_CURRENT_FOURTH) >> 15);
}
void TMC26XStepper::setEnabled(boolean enabled) {
@ -693,7 +693,7 @@ boolean TMC26XStepper::isEnabled() { return !!(chopper_config_register & T_OFF_P
*
*/
void TMC26XStepper::readStatus(char read_value) {
unsigned long old_driver_configuration_register_value = driver_configuration_register_value;
uint32_t 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
@ -712,42 +712,42 @@ void TMC26XStepper::readStatus(char read_value) {
send262(driver_configuration_register_value);
}
int TMC26XStepper::getMotorPosition(void) {
int16_t 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
//reads the StallGuard setting from last status
//returns -1 if StallGuard information is not present
int16_t TMC26XStepper::getCurrentStallGuardReading(void) {
//if we don't yet started there cannot be a StallGuard value
if (!started) return -1;
//not time optimal, but solution optiomal:
//first read out the stall guard value
//first read out the StallGuard 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
uint8_t TMC26XStepper::getCurrentCSReading(void) {
//if we don't yet started there cannot be a StallGuard value
if (!started) return 0;
//not time optimal, but solution optiomal:
//first read out the stall guard value
//first read out the StallGuard value
readStatus(TMC26X_READOUT_CURRENT);
return (getReadoutValue() & 0x1F);
}
unsigned int TMC26XStepper::getCurrentCurrent(void) {
uint16_t TMC26XStepper::getCurrentCurrent(void) {
float result = (float)getCurrentCSReading(),
resistor_value = (float)this->resistor,
voltage = (driver_configuration_register_value & VSENSE)? 0.165 : 0.31;
result = (result + 1.0) / 32.0 * voltage / resistor_value * sq(1000.0);
return (unsigned int)result;
return (uint16_t)result;
}
/**
* Return true if the stallguard threshold has been reached
* Return true if the StallGuard threshold has been reached
*/
boolean TMC26XStepper::isStallGuardOverThreshold(void) {
if (!this->started) return false;
@ -808,13 +808,13 @@ boolean TMC26XStepper::isStallGuardReached(void) {
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) {
//reads the StallGuard setting from last status
//returns -1 if StallGuard information is not present
int16_t TMC26XStepper::getReadoutValue(void) {
return (int)(driver_status_result >> 10);
}
int TMC26XStepper::getResistor() { return this->resistor; }
int16_t TMC26XStepper::getResistor() { return this->resistor; }
boolean TMC26XStepper::isCurrentScalingHalfed() {
return !!(this->driver_configuration_register_value & VSENSE);
@ -822,7 +822,7 @@ boolean TMC26XStepper::isCurrentScalingHalfed() {
/**
* version() returns the version of the library:
*/
int TMC26XStepper::version(void) { return 1; }
int16_t TMC26XStepper::version(void) { return 1; }
void TMC26XStepper::debugLastStatus() {
#ifdef TMC_DEBUG1
@ -850,8 +850,8 @@ void TMC26XStepper::debugLastStatus() {
if (this->isStandStill())
SERIAL_ECHOLNPGM("\n INFO: Motor is standing still.");
unsigned long readout_config = driver_configuration_register_value & READ_SELECTION_PATTERN;
const int value = getReadoutValue();
uint32_t readout_config = driver_configuration_register_value & READ_SELECTION_PATTERN;
const int16_t value = getReadoutValue();
if (readout_config == READ_MICROSTEP_POSTION) {
//SERIAL_PRINTF("Microstep postion phase A: ");
SERIAL_ECHOPAIR("\n Microstep postion phase A: ", value);
@ -861,7 +861,7 @@ void TMC26XStepper::debugLastStatus() {
SERIAL_ECHOPAIR("\n Stall Guard value:", value);
}
else if (readout_config == READ_STALL_GUARD_AND_COOL_STEP) {
int stallGuard = value & 0xF, current = value & 0x1F0;
int16_t stallGuard = value & 0xF, current = value & 0x1F0;
//SERIAL_PRINTF("Approx Stall Guard: ");
SERIAL_ECHOPAIR("\n Approx Stall Guard: ", stallGuard);
//SERIAL_PRINTF("Current level");
@ -875,11 +875,11 @@ void TMC26XStepper::debugLastStatus() {
* send register settings to the stepper driver via SPI
* returns the current status
*/
inline void TMC26XStepper::send262(unsigned long datagram) {
unsigned long i_datagram;
inline void TMC26XStepper::send262(uint32_t datagram) {
uint32_t i_datagram;
//preserver the previous spi mode
//unsigned char oldMode = SPCR & SPI_MODE_MASK;
//uint8_t oldMode = SPCR & SPI_MODE_MASK;
//if the mode is not correct set it to mode 3
//if (oldMode != SPI_MODE3) {

96
Marlin/src/HAL/HAL_STM32F7/TMC2660.h
View File

@ -83,7 +83,7 @@
* \code
* TMC26XStepper stepper = TMC26XStepper(200,1,2,3,500);
* \endcode
* see TMC26XStepper(int number_of_steps, int cs_pin, int dir_pin, int step_pin, unsigned int rms_current)
* see TMC26XStepper(int16_t number_of_steps, int16_t cs_pin, int16_t dir_pin, int16_t step_pin, uint16_t rms_current)
*
* Keep in mind that you need to start the driver with start() in order to get the TMC26X configured.
*
@ -122,7 +122,7 @@ class TMC26XStepper {
* You can select a different stepping with setMicrosteps() to aa different value.
* \sa start(), setMicrosteps()
*/
TMC26XStepper(int number_of_steps, int cs_pin, int dir_pin, int step_pin, unsigned int current, unsigned int resistor=100); //resistor=150
TMC26XStepper(int16_t number_of_steps, int16_t cs_pin, int16_t dir_pin, int16_t step_pin, uint16_t current, uint16_t resistor=100); //resistor=150
/*!
* \brief configures and starts the TMC26X stepper driver. Before you called this function the stepper driver is in nonfunctional mode.
@ -150,13 +150,13 @@ class TMC26XStepper {
* \brief Sets the rotation speed in revolutions per minute.
* \param whatSpeed the desired speed in rotations per minute.
*/
void setSpeed(unsigned int whatSpeed);
void setSpeed(uint16_t whatSpeed);
/*!
* \brief reads out the currently selected speed in revolutions per minute.
* \sa setSpeed()
*/
unsigned int getSpeed(void);
uint16_t getSpeed(void);
/*!
* \brief Set the number of microsteps in 2^i values (rounded) up to 256
@ -166,7 +166,7 @@ class TMC26XStepper {
* If you give any other value it will be rounded to the next smaller number (3 would give a microstepping of 2).
* You can always check the current microstepping with getMicrosteps().
*/
void setMicrosteps(int number_of_steps);
void setMicrosteps(int16_t number_of_steps);
/*!
* \brief returns the effective current number of microsteps selected.
@ -176,7 +176,7 @@ class TMC26XStepper {
*
* \sa setMicrosteps()
*/
int getMicrosteps(void);
int16_t getMicrosteps(void);
/*!
* \brief Initiate a movement for the given number of steps. Positive numbers move in one, negative numbers in the other direction.
@ -193,7 +193,7 @@ class TMC26XStepper {
* You can always verify with isMoving() or even use stop() to stop the motor before giving it new step directions.
* \sa isMoving(), getStepsLeft(), stop()
*/
char step(int number_of_steps);
char step(int16_t number_of_steps);
/*!
* \brief Central movement method, must be called as often as possible in the lopp function and is very fast.
@ -228,7 +228,7 @@ class TMC26XStepper {
* \brief Get the number of steps left in the current movement.
* \return The number of steps left in the movement. This number is always positive.
*/
unsigned int getStepsLeft(void);
uint16_t getStepsLeft(void);
/*!
* \brief Stops the motor regardless if it moves or not.
@ -262,7 +262,7 @@ class TMC26XStepper {
* \sa setSpreadCycleChoper() for other alternatives.
* \sa setRandomOffTime() for spreading the noise over a wider spectrum
*/
void setConstantOffTimeChopper(char constant_off_time, char blank_time, char fast_decay_time_setting, char sine_wave_offset, unsigned char use_current_comparator);
void setConstantOffTimeChopper(char constant_off_time, char blank_time, char fast_decay_time_setting, char sine_wave_offset, uint8_t use_current_comparator);
/*!
* \brief Sets and configures with spread cycle chopper.
@ -310,7 +310,7 @@ class TMC26XStepper {
* \param current the maximum motor current in mA
* \sa getCurrent(), getCurrentCurrent()
*/
void setCurrent(unsigned int current);
void setCurrent(uint16_t current);
/*!
* \brief readout the motor maximum current in mA (1000 is an Amp)
@ -318,12 +318,12 @@ class TMC26XStepper {
* \return the maximum motor current in milli amps
* \sa getCurrentCurrent()
*/
unsigned int getCurrent(void);
uint16_t getCurrent(void);
/*!
* \brief set the StallGuard threshold in order to get sensible StallGuard readings.
* \param stall_guard_threshold -64 … 63 the StallGuard threshold
* \param stall_guard_filter_enabled 0 if the filter is disabled, -1 if it is enabled
* \param stallguard_threshold -64 … 63 the StallGuard threshold
* \param stallguard_filter_enabled 0 if the filter is disabled, -1 if it is enabled
*
* The StallGuard threshold is used to optimize the StallGuard reading to sensible values. It should be at 0 at
* the maximum allowable load on the otor (but not before). = is a good starting point (and the default)
@ -335,7 +335,7 @@ class TMC26XStepper {
*
* \sa getCurrentStallGuardReading() to read out the current value.
*/
void setStallGuardThreshold(char stall_guard_threshold, char stall_guard_filter_enabled);
void setStallGuardThreshold(char stallguard_threshold, char stallguard_filter_enabled);
/*!
* \brief reads out the StallGuard threshold
@ -366,8 +366,8 @@ class TMC26XStepper {
* (1/2 or 1/4th otf the configured current).
* \sa COOL_STEP_HALF_CS_LIMIT, COOL_STEP_QUARTER_CS_LIMIT
*/
void 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);
void setCoolStepConfiguration(uint16_t lower_SG_threshold, uint16_t SG_hysteresis, uint8_t current_decrement_step_size,
uint8_t current_increment_step_size, uint8_t lower_current_limit);
/*!
* \brief enables or disables the CoolStep smart energy operation feature. It must be configured before enabling it.
@ -387,32 +387,32 @@ class TMC26XStepper {
* \brief returns the lower StallGuard threshold for the CoolStep operation
* \sa setCoolStepConfiguration()
*/
unsigned int getCoolStepLowerSgThreshold();
uint16_t getCoolStepLowerSgThreshold();
/*!
* \brief returns the upper StallGuard threshold for the CoolStep operation
* \sa setCoolStepConfiguration()
*/
unsigned int getCoolStepUpperSgThreshold();
uint16_t getCoolStepUpperSgThreshold();
/*!
* \brief returns the number of StallGuard readings befor CoolStep adjusts the motor current.
* \sa setCoolStepConfiguration()
*/
unsigned char getCoolStepNumberOfSGReadings();
uint8_t getCoolStepNumberOfSGReadings();
/*!
* \brief returns the increment steps for the current for the CoolStep operation
* \sa setCoolStepConfiguration()
*/
unsigned char getCoolStepCurrentIncrementSize();
uint8_t getCoolStepCurrentIncrementSize();
/*!
* \brief returns the absolut minium current for the CoolStep operation
* \sa setCoolStepConfiguration()
* \sa COOL_STEP_HALF_CS_LIMIT, COOL_STEP_QUARTER_CS_LIMIT
*/
unsigned char getCoolStepLowerCurrentLimit();
uint8_t getCoolStepLowerCurrentLimit();
/*!
* \brief Get the current microstep position for phase A
@ -420,7 +420,7 @@ class TMC26XStepper {
*
* Keep in mind that this routine reads and writes a value via SPI - so this may take a bit time.
*/
int getMotorPosition(void);
int16_t getMotorPosition(void);
/*!
* \brief Reads the current StallGuard value.
@ -428,14 +428,14 @@ class TMC26XStepper {
* Keep in mind that this routine reads and writes a value via SPI - so this may take a bit time.
* \sa setStallGuardThreshold() for tuning the readout to sensible ranges.
*/
int getCurrentStallGuardReading(void);
int16_t getCurrentStallGuardReading(void);
/*!
* \brief Reads the current current setting value as fraction of the maximum current
* Returns values between 0 and 31, representing 1/32 to 32/32 (=1)
* \sa setCoolStepConfiguration()
*/
unsigned char getCurrentCSReading(void);
uint8_t getCurrentCSReading(void);
/*!
@ -451,7 +451,7 @@ class TMC26XStepper {
* may not be the fastest.
* \sa getCurrentCSReading(), getResistor(), isCurrentScalingHalfed(), getCurrent()
*/
unsigned int getCurrentCurrent(void);
uint16_t getCurrentCurrent(void);
/*!
* \brief checks if there is a StallGuard warning in the last status
@ -552,56 +552,54 @@ class TMC26XStepper {
* \brief Returns the current sense resistor value in milliohm.
* The default value of ,15 Ohm will return 150.
*/
int getResistor();
int16_t getResistor();
/*!
* \brief Prints out all the information that can be found in the last status read out - it does not force a status readout.
* The result is printed via Serial
*/
void debugLastStatus(void);
/*!
* \brief library version
* \return the version number as int.
*/
int version(void);
int16_t version(void);
private:
unsigned int steps_left; // The steps the motor has to do to complete the movement
int direction; // Direction of rotation
unsigned long step_delay; // Delay between steps, in ms, based on speed
int number_of_steps; // Total number of steps this motor can take
unsigned int speed; // Store the current speed in order to change the speed after changing microstepping
unsigned int resistor; // Current sense resitor value in milliohm
uint16_t steps_left; // The steps the motor has to do to complete the movement
int16_t direction; // Direction of rotation
uint32_t step_delay; // Delay between steps, in ms, based on speed
int16_t number_of_steps; // Total number of steps this motor can take
uint16_t speed; // Store the current speed in order to change the speed after changing microstepping
uint16_t resistor; // Current sense resitor value in milliohm
unsigned long last_step_time; // Time stamp in ms of when the last step was taken
unsigned long next_step_time; // Time stamp in ms of when the last step was taken
uint32_t last_step_time, // Timestamp (ms) of the last step
next_step_time; // Timestamp (ms) of the next step
// Driver control register copies to easily set & modify the registers
unsigned long driver_control_register_value;
unsigned long chopper_config_register;
unsigned long cool_step_register_value;
unsigned long stall_guard2_current_register_value;
unsigned long driver_configuration_register_value;
// The driver status result
unsigned long driver_status_result;
uint32_t driver_control_register_value,
chopper_config_register,
cool_step_register_value,
stallguard2_current_register_value,
driver_configuration_register_value,
driver_status_result; // The driver status result
// Helper routione to get the top 10 bit of the readout
inline int getReadoutValue();
inline int16_t getReadoutValue();
// The pins for the stepper driver
unsigned char cs_pin;
unsigned char step_pin;
unsigned char dir_pin;
uint8_t cs_pin, step_pin, dir_pin;
// Status values
boolean started; // If the stepper has been started yet
int microsteps; // The current number of micro steps
int16_t microsteps; // The current number of micro steps
char constant_off_time; // We need to remember this value in order to enable and disable the motor
unsigned char cool_step_lower_threshold; // we need to remember the threshold to enable and disable the CoolStep feature
uint8_t cool_step_lower_threshold; // we need to remember the threshold to enable and disable the CoolStep feature
boolean cool_step_enabled; // We need to remember this to configure the coolstep if it si enabled
// SPI sender
inline void send262(unsigned long datagram);
inline void send262(uint32_t datagram);
};
#endif // _TMC26XSTEPPER_H_

Write Preview
Loading…
Cancel
Save