Initial commit
This commit is contained in:
790
TMC2209/lib/tmc/boards/TMC2209_eval.c
Normal file
790
TMC2209/lib/tmc/boards/TMC2209_eval.c
Normal file
@@ -0,0 +1,790 @@
|
||||
/*******************************************************************************
|
||||
* Copyright © 2019 TRINAMIC Motion Control GmbH & Co. KG
|
||||
* (now owned by Analog Devices Inc.),
|
||||
*
|
||||
* Copyright © 2023 Analog Devices Inc. All Rights Reserved. This software is
|
||||
* proprietary & confidential to Analog Devices, Inc. and its licensors.
|
||||
*******************************************************************************/
|
||||
|
||||
|
||||
#include "Board.h"
|
||||
#include "tmc/ic/TMC2209/TMC2209.h"
|
||||
#include "tmc/StepDir.h"
|
||||
|
||||
#undef TMC2209_MAX_VELOCITY
|
||||
#define TMC2209_MAX_VELOCITY STEPDIR_MAX_VELOCITY
|
||||
|
||||
// Stepdir precision: 2^17 -> 17 digits of precision
|
||||
#define STEPDIR_PRECISION 131072
|
||||
|
||||
#define ERRORS_VM (1<<0)
|
||||
#define ERRORS_VM_UNDER (1<<1)
|
||||
#define ERRORS_VM_OVER (1<<2)
|
||||
|
||||
#define VM_MIN 50 // VM[V/10] min
|
||||
#define VM_MAX 390 // VM[V/10] max
|
||||
|
||||
#define MOTORS 1
|
||||
|
||||
#define VREF_FULLSCALE 2100 // mV // with R308 achievable Vref_max is ~2100mV
|
||||
//#define VREF_FULLSCALE 3300 // mV // without R308 achievable Vref_max is ~2500mV
|
||||
|
||||
|
||||
static uint32_t right(uint8_t motor, int32_t velocity);
|
||||
static uint32_t left(uint8_t motor, int32_t velocity);
|
||||
static uint32_t rotate(uint8_t motor, int32_t velocity);
|
||||
static uint32_t stop(uint8_t motor);
|
||||
static uint32_t moveTo(uint8_t motor, int32_t position);
|
||||
static uint32_t moveBy(uint8_t motor, int32_t *ticks);
|
||||
static uint32_t GAP(uint8_t type, uint8_t motor, int32_t *value);
|
||||
static uint32_t SAP(uint8_t type, uint8_t motor, int32_t value);
|
||||
|
||||
static void checkErrors (uint32_t tick);
|
||||
static void deInit(void);
|
||||
static uint32_t userFunction(uint8_t type, uint8_t motor, int32_t *value);
|
||||
|
||||
static void periodicJob(uint32_t tick);
|
||||
static uint8_t reset(void);
|
||||
static uint8_t restore(void);
|
||||
static void enableDriver(DriverState state);
|
||||
|
||||
static UART_Config *TMC2209_UARTChannel;
|
||||
static ConfigurationTypeDef *TMC2209_config;
|
||||
|
||||
static uint16_t vref; // mV
|
||||
static int32_t thigh;
|
||||
|
||||
static timer_channel timerChannel;
|
||||
// Helper macro - Access the chip object in the driver boards union
|
||||
#define TMC2209 (driverBoards.tmc2209)
|
||||
|
||||
// Helper macro - index is always 1 here (channel 1 <-> index 0, channel 2 <-> index 1)
|
||||
#define TMC2209_CRC(data, length) tmc_CRC8(data, length, 1)
|
||||
|
||||
typedef struct
|
||||
{
|
||||
IOPinTypeDef *ENN;
|
||||
IOPinTypeDef *SPREAD;
|
||||
IOPinTypeDef *STEP;
|
||||
IOPinTypeDef *DIR;
|
||||
IOPinTypeDef *MS1_AD0;
|
||||
IOPinTypeDef *MS2_AD1;
|
||||
IOPinTypeDef *DIAG;
|
||||
IOPinTypeDef *INDEX;
|
||||
IOPinTypeDef *UC_PWM;
|
||||
IOPinTypeDef *STDBY;
|
||||
} PinsTypeDef;
|
||||
|
||||
static PinsTypeDef Pins;
|
||||
|
||||
static inline TMC2209TypeDef *motorToIC(uint8_t motor)
|
||||
{
|
||||
UNUSED(motor);
|
||||
|
||||
return &TMC2209;
|
||||
}
|
||||
|
||||
static inline UART_Config *channelToUART(uint8_t channel)
|
||||
{
|
||||
UNUSED(channel);
|
||||
|
||||
return TMC2209_UARTChannel;
|
||||
}
|
||||
|
||||
// => UART wrapper
|
||||
// Write [writeLength] bytes from the [data] array.
|
||||
// If [readLength] is greater than zero, read [readLength] bytes from the
|
||||
// [data] array.
|
||||
void tmc2209_readWriteArray(uint8_t channel, uint8_t *data, size_t writeLength, size_t readLength)
|
||||
{
|
||||
UART_readWrite(channelToUART(channel), data, writeLength, readLength);
|
||||
}
|
||||
// <= UART wrapper
|
||||
|
||||
// => CRC wrapper
|
||||
// Return the CRC8 of [length] bytes of data stored in the [data] array.
|
||||
uint8_t tmc2209_CRC8(uint8_t *data, size_t length)
|
||||
{
|
||||
return TMC2209_CRC(data, length);
|
||||
}
|
||||
// <= CRC wrapper
|
||||
|
||||
void tmc2209_writeRegister(uint8_t motor, uint16_t address, int32_t value)
|
||||
{
|
||||
tmc2209_writeInt(motorToIC(motor), (uint8_t) address, value);
|
||||
|
||||
}
|
||||
|
||||
void tmc2209_readRegister(uint8_t motor, uint16_t address, int32_t *value)
|
||||
{
|
||||
*value = tmc2209_readInt(motorToIC(motor), (uint8_t) address);
|
||||
}
|
||||
|
||||
static uint32_t rotate(uint8_t motor, int32_t velocity)
|
||||
{
|
||||
if(motor >= MOTORS)
|
||||
return TMC_ERROR_MOTOR;
|
||||
|
||||
StepDir_rotate(motor, velocity);
|
||||
|
||||
return TMC_ERROR_NONE;
|
||||
}
|
||||
|
||||
static uint32_t right(uint8_t motor, int32_t velocity)
|
||||
{
|
||||
return rotate(motor, velocity);
|
||||
}
|
||||
|
||||
static uint32_t left(uint8_t motor, int32_t velocity)
|
||||
{
|
||||
return rotate(motor, -velocity);
|
||||
}
|
||||
|
||||
static uint32_t stop(uint8_t motor)
|
||||
{
|
||||
return rotate(motor, 0);
|
||||
}
|
||||
|
||||
static uint32_t moveTo(uint8_t motor, int32_t position)
|
||||
{
|
||||
if(motor >= MOTORS)
|
||||
return TMC_ERROR_MOTOR;
|
||||
|
||||
StepDir_moveTo(motor, position);
|
||||
|
||||
return TMC_ERROR_NONE;
|
||||
}
|
||||
|
||||
static uint32_t moveBy(uint8_t motor, int32_t *ticks)
|
||||
{
|
||||
if(motor >= MOTORS)
|
||||
return TMC_ERROR_MOTOR;
|
||||
|
||||
// determine actual position and add numbers of ticks to move
|
||||
*ticks += StepDir_getActualPosition(motor);
|
||||
|
||||
return moveTo(motor, *ticks);
|
||||
}
|
||||
|
||||
static uint32_t handleParameter(uint8_t readWrite, uint8_t motor, uint8_t type, int32_t *value)
|
||||
{
|
||||
uint32_t errors = TMC_ERROR_NONE;
|
||||
int32_t buffer = 0;
|
||||
|
||||
if(motor >= MOTORS)
|
||||
return TMC_ERROR_MOTOR;
|
||||
|
||||
switch(type)
|
||||
{
|
||||
case 0:
|
||||
// Target position
|
||||
if(readWrite == READ) {
|
||||
*value = StepDir_getTargetPosition(motor);
|
||||
} else if(readWrite == WRITE) {
|
||||
StepDir_moveTo(motor, *value);
|
||||
}
|
||||
break;
|
||||
case 1:
|
||||
// Actual position
|
||||
if(readWrite == READ) {
|
||||
*value = StepDir_getActualPosition(motor);
|
||||
} else if(readWrite == WRITE) {
|
||||
StepDir_setActualPosition(motor, *value);
|
||||
}
|
||||
break;
|
||||
case 2:
|
||||
// Target speed
|
||||
if(readWrite == READ) {
|
||||
*value = StepDir_getTargetVelocity(motor);
|
||||
} else if(readWrite == WRITE) {
|
||||
StepDir_rotate(motor, *value);
|
||||
}
|
||||
break;
|
||||
case 3:
|
||||
// Actual speed
|
||||
if(readWrite == READ) {
|
||||
*value = StepDir_getActualVelocity(motor);
|
||||
} else if(readWrite == WRITE) {
|
||||
errors |= TMC_ERROR_TYPE;
|
||||
}
|
||||
break;
|
||||
case 4:
|
||||
// Maximum speed
|
||||
if(readWrite == READ) {
|
||||
*value = StepDir_getVelocityMax(motor);
|
||||
} else if(readWrite == WRITE) {
|
||||
StepDir_setVelocityMax(motor, abs(*value));
|
||||
}
|
||||
break;
|
||||
case 5:
|
||||
// Maximum acceleration
|
||||
if(readWrite == READ) {
|
||||
*value = StepDir_getAcceleration(motor);
|
||||
} else if(readWrite == WRITE) {
|
||||
StepDir_setAcceleration(motor, *value);
|
||||
}
|
||||
break;
|
||||
case 6:
|
||||
// Maximum current
|
||||
if(readWrite == READ) {
|
||||
*value = TMC2209_FIELD_READ(motorToIC(motor), TMC2209_IHOLD_IRUN, TMC2209_IRUN_MASK, TMC2209_IRUN_SHIFT);
|
||||
} else if(readWrite == WRITE) {
|
||||
TMC2209_FIELD_UPDATE(motorToIC(motor), TMC2209_IHOLD_IRUN, TMC2209_IRUN_MASK, TMC2209_IRUN_SHIFT, *value);
|
||||
}
|
||||
break;
|
||||
case 7:
|
||||
// Standby current
|
||||
if(readWrite == READ) {
|
||||
*value = TMC2209_FIELD_READ(motorToIC(motor), TMC2209_IHOLD_IRUN, TMC2209_IHOLD_MASK, TMC2209_IHOLD_SHIFT);
|
||||
} else if(readWrite == WRITE) {
|
||||
TMC2209_FIELD_UPDATE(motorToIC(motor), TMC2209_IHOLD_IRUN, TMC2209_IHOLD_MASK, TMC2209_IHOLD_SHIFT, *value);
|
||||
}
|
||||
break;
|
||||
case 8:
|
||||
// Position reached flag
|
||||
if(readWrite == READ) {
|
||||
*value = (StepDir_getStatus(motor) & STATUS_TARGET_REACHED)? 1:0;
|
||||
} else if(readWrite == WRITE) {
|
||||
errors |= TMC_ERROR_TYPE;
|
||||
}
|
||||
break;
|
||||
case 9:
|
||||
// VREF
|
||||
if (readWrite == READ) {
|
||||
*value = vref;
|
||||
} else {
|
||||
if ((uint32_t) *value < VREF_FULLSCALE) {
|
||||
vref = *value;
|
||||
Timer.setDuty(timerChannel, ((float)vref) / VREF_FULLSCALE);
|
||||
} else {
|
||||
errors |= TMC_ERROR_VALUE;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case 23:
|
||||
// Speed threshold for high speed mode
|
||||
if(readWrite == READ) {
|
||||
buffer = thigh;
|
||||
*value = MIN(0xFFFFF, (1<<24) / ((buffer) ? buffer : 1));
|
||||
} else if(readWrite == WRITE) {
|
||||
*value = MIN(0xFFFFF, (1<<24) / ((*value) ? *value : 1));
|
||||
thigh = *value;
|
||||
}
|
||||
break;
|
||||
case 28:
|
||||
// Internal RSense
|
||||
if(readWrite == READ) {
|
||||
*value = TMC2209_FIELD_READ(motorToIC(motor), TMC2209_GCONF, TMC2209_INTERNAL_RSENSE_MASK, TMC2209_INTERNAL_RSENSE_SHIFT);
|
||||
} else if(readWrite == WRITE) {
|
||||
TMC2209_FIELD_UPDATE(motorToIC(motor), TMC2209_GCONF, TMC2209_INTERNAL_RSENSE_MASK, TMC2209_INTERNAL_RSENSE_SHIFT, *value);
|
||||
}
|
||||
break;
|
||||
case 29:
|
||||
// Measured Speed
|
||||
if(readWrite == READ) {
|
||||
buffer = (int32_t)(((int64_t)StepDir_getFrequency(motor) * (int64_t)122) / (int64_t)TMC2209_FIELD_READ(motorToIC(motor), TMC2209_TSTEP, TMC2209_TSTEP_MASK, TMC2209_TSTEP_SHIFT));
|
||||
*value = (abs(buffer) < 20) ? 0 : buffer;
|
||||
} else if(readWrite == WRITE) {
|
||||
errors |= TMC_ERROR_TYPE;
|
||||
}
|
||||
break;
|
||||
case 50: // StepDir internal(0)/external(1)
|
||||
if(readWrite == READ) {
|
||||
*value = StepDir_getMode(motor);
|
||||
} else if(readWrite == WRITE) {
|
||||
StepDir_setMode(motor, *value);
|
||||
}
|
||||
break;
|
||||
case 51: // StepDir interrupt frequency
|
||||
if(readWrite == READ) {
|
||||
*value = StepDir_getFrequency(motor);
|
||||
} else if(readWrite == WRITE) {
|
||||
StepDir_setFrequency(motor, *value);
|
||||
}
|
||||
break;
|
||||
case 140:
|
||||
// Microstep Resolution
|
||||
if(readWrite == READ) {
|
||||
*value = 256 >> TMC2209_FIELD_READ(motorToIC(motor), TMC2209_CHOPCONF, TMC2209_MRES_MASK, TMC2209_MRES_SHIFT);
|
||||
} else if(readWrite == WRITE) {
|
||||
switch(*value)
|
||||
{
|
||||
case 1: *value = 8; break;
|
||||
case 2: *value = 7; break;
|
||||
case 4: *value = 6; break;
|
||||
case 8: *value = 5; break;
|
||||
case 16: *value = 4; break;
|
||||
case 32: *value = 3; break;
|
||||
case 64: *value = 2; break;
|
||||
case 128: *value = 1; break;
|
||||
case 256: *value = 0; break;
|
||||
default: *value = -1; break;
|
||||
}
|
||||
|
||||
if(*value != -1)
|
||||
{
|
||||
TMC2209_FIELD_UPDATE(motorToIC(motor), TMC2209_CHOPCONF, TMC2209_MRES_MASK, TMC2209_MRES_SHIFT, *value);
|
||||
}
|
||||
else
|
||||
{
|
||||
errors |= TMC_ERROR_VALUE;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case 162:
|
||||
// Chopper blank time
|
||||
if(readWrite == READ) {
|
||||
*value = TMC2209_FIELD_READ(motorToIC(motor), TMC2209_CHOPCONF, TMC2209_TBL_MASK, TMC2209_TBL_SHIFT);
|
||||
} else if(readWrite == WRITE) {
|
||||
TMC2209_FIELD_UPDATE(motorToIC(motor), TMC2209_CHOPCONF, TMC2209_TBL_MASK, TMC2209_TBL_SHIFT, *value);
|
||||
}
|
||||
break;
|
||||
case 165:
|
||||
// Chopper hysteresis end / fast decay time
|
||||
if(readWrite == READ) {
|
||||
if(tmc2209_readInt(motorToIC(motor), TMC2209_CHOPCONF) & (1<<14))
|
||||
{
|
||||
*value = TMC2209_FIELD_READ(motorToIC(motor), TMC2209_CHOPCONF, TMC2209_HEND_MASK, TMC2209_HEND_SHIFT);
|
||||
}
|
||||
else
|
||||
{
|
||||
buffer = tmc2209_readInt(motorToIC(motor), TMC2209_CHOPCONF);
|
||||
*value = (tmc2209_readInt(motorToIC(motor), TMC2209_CHOPCONF) >> 4) & 0x07;
|
||||
if(buffer & (1<<11))
|
||||
*value |= 1<<3;
|
||||
}
|
||||
} else if(readWrite == WRITE) {
|
||||
errors |= TMC_ERROR_TYPE;
|
||||
}
|
||||
break;
|
||||
case 166:
|
||||
// Chopper hysteresis start / sine wave offset
|
||||
if(readWrite == READ) {
|
||||
if(tmc2209_readInt(motorToIC(motor), TMC2209_CHOPCONF) & (1<<14))
|
||||
{
|
||||
*value = TMC2209_FIELD_READ(motorToIC(motor), TMC2209_CHOPCONF, TMC2209_HSTRT_MASK, TMC2209_HSTRT_SHIFT);
|
||||
}
|
||||
else
|
||||
{
|
||||
buffer = tmc2209_readInt(motorToIC(motor), TMC2209_CHOPCONF);
|
||||
*value = (tmc2209_readInt(motorToIC(motor), TMC2209_CHOPCONF) >> 7) & 0x0F;
|
||||
if(buffer & (1<<11))
|
||||
*value |= 1<<3;
|
||||
}
|
||||
} else if(readWrite == WRITE) {
|
||||
if(tmc2209_readInt(motorToIC(motor), TMC2209_CHOPCONF) & (1<<14))
|
||||
{
|
||||
TMC2209_FIELD_UPDATE(motorToIC(motor), TMC2209_CHOPCONF, TMC2209_HSTRT_MASK, TMC2209_HSTRT_SHIFT, *value);
|
||||
}
|
||||
else
|
||||
{
|
||||
TMC2209_FIELD_UPDATE(motorToIC(motor), TMC2209_CHOPCONF, TMC2209_HEND_MASK, TMC2209_HEND_SHIFT, *value);
|
||||
}
|
||||
}
|
||||
break;
|
||||
case 167:
|
||||
// Chopper off time
|
||||
if(readWrite == READ) {
|
||||
*value = TMC2209_FIELD_READ(motorToIC(motor), TMC2209_CHOPCONF, TMC2209_TOFF_MASK, TMC2209_TOFF_SHIFT);
|
||||
} else if(readWrite == WRITE) {
|
||||
TMC2209_FIELD_UPDATE(motorToIC(motor), TMC2209_CHOPCONF, TMC2209_TOFF_MASK, TMC2209_TOFF_SHIFT, *value);
|
||||
}
|
||||
break;
|
||||
case 168:
|
||||
// smartEnergy current minimum (SEIMIN)
|
||||
if(readWrite == READ) {
|
||||
*value = TMC2209_FIELD_READ(motorToIC(motor), TMC2209_COOLCONF, TMC2209_SEIMIN_MASK, TMC2209_SEIMIN_SHIFT);
|
||||
} else if(readWrite == WRITE) {
|
||||
TMC2209_FIELD_UPDATE(motorToIC(motor), TMC2209_COOLCONF, TMC2209_SEIMIN_MASK, TMC2209_SEIMIN_SHIFT, *value);
|
||||
}
|
||||
break;
|
||||
case 169:
|
||||
// smartEnergy current down step
|
||||
if(readWrite == READ) {
|
||||
*value = TMC2209_FIELD_READ(motorToIC(motor), TMC2209_COOLCONF, TMC2209_SEDN_MASK, TMC2209_SEDN_SHIFT);
|
||||
} else if(readWrite == WRITE) {
|
||||
TMC2209_FIELD_UPDATE(motorToIC(motor), TMC2209_COOLCONF, TMC2209_SEDN_MASK, TMC2209_SEDN_SHIFT, *value);
|
||||
}
|
||||
break;
|
||||
case 170:
|
||||
// smartEnergy hysteresis
|
||||
if(readWrite == READ) {
|
||||
*value = TMC2209_FIELD_READ(motorToIC(motor), TMC2209_COOLCONF, TMC2209_SEMAX_MASK, TMC2209_SEMAX_SHIFT);
|
||||
} else if(readWrite == WRITE) {
|
||||
TMC2209_FIELD_UPDATE(motorToIC(motor), TMC2209_COOLCONF, TMC2209_SEMAX_MASK, TMC2209_SEMAX_SHIFT, *value);
|
||||
}
|
||||
break;
|
||||
case 171:
|
||||
// smartEnergy current up step
|
||||
if(readWrite == READ) {
|
||||
*value = TMC2209_FIELD_READ(motorToIC(motor), TMC2209_COOLCONF, TMC2209_SEUP_MASK, TMC2209_SEUP_SHIFT);
|
||||
} else if(readWrite == WRITE) {
|
||||
TMC2209_FIELD_UPDATE(motorToIC(motor), TMC2209_COOLCONF, TMC2209_SEUP_MASK, TMC2209_SEUP_SHIFT, *value);
|
||||
}
|
||||
break;
|
||||
case 172:
|
||||
// smartEnergy hysteresis start
|
||||
if(readWrite == READ) {
|
||||
*value = TMC2209_FIELD_READ(motorToIC(motor), TMC2209_COOLCONF, TMC2209_SEMIN_MASK, TMC2209_SEMIN_SHIFT);
|
||||
} else if(readWrite == WRITE) {
|
||||
TMC2209_FIELD_UPDATE(motorToIC(motor), TMC2209_COOLCONF, TMC2209_SEMIN_MASK, TMC2209_SEMIN_SHIFT, *value);
|
||||
}
|
||||
break;
|
||||
case 174:
|
||||
// stallGuard2 threshold
|
||||
if(readWrite == READ) {
|
||||
*value = tmc2209_readInt(motorToIC(motor), TMC2209_SGTHRS);
|
||||
} else if(readWrite == WRITE) {
|
||||
tmc2209_writeInt(motorToIC(motor), TMC2209_SGTHRS, *value);
|
||||
}
|
||||
break;
|
||||
case 179:
|
||||
// VSense
|
||||
if(readWrite == READ) {
|
||||
*value = TMC2209_FIELD_READ(motorToIC(motor), TMC2209_CHOPCONF, TMC2209_VSENSE_MASK, TMC2209_VSENSE_SHIFT);
|
||||
} else if(readWrite == WRITE) {
|
||||
TMC2209_FIELD_UPDATE(motorToIC(motor), TMC2209_CHOPCONF, TMC2209_VSENSE_MASK, TMC2209_VSENSE_SHIFT, *value);
|
||||
}
|
||||
break;
|
||||
case 180:
|
||||
// smartEnergy actual current
|
||||
if(readWrite == READ) {
|
||||
*value = TMC2209_FIELD_READ(motorToIC(motor), TMC2209_DRVSTATUS, TMC2209_CS_ACTUAL_MASK, TMC2209_CS_ACTUAL_SHIFT);
|
||||
} else if(readWrite == WRITE) {
|
||||
errors |= TMC_ERROR_TYPE;
|
||||
}
|
||||
break;
|
||||
case 181:
|
||||
// smartEnergy stall velocity
|
||||
if(readWrite == READ) {
|
||||
*value = StepDir_getStallGuardThreshold(motor);
|
||||
} else if(readWrite == WRITE) {
|
||||
// Store the threshold value in the internal StepDir generator
|
||||
StepDir_setStallGuardThreshold(motor, *value);
|
||||
|
||||
// Convert the value for the TCOOLTHRS register
|
||||
// The IC only sends out Stallguard errors while TCOOLTHRS >= TSTEP >= TPWMTHRS
|
||||
// The TSTEP value is measured. To prevent measurement inaccuracies hiding
|
||||
// a stall signal, we decrease the needed velocity by roughly 12% before converting it.
|
||||
*value -= (*value) >> 3;
|
||||
if (*value)
|
||||
{
|
||||
*value = MIN(0x000FFFFF, (1<<24) / (*value));
|
||||
}
|
||||
else
|
||||
{
|
||||
*value = 0x000FFFFF;
|
||||
}
|
||||
tmc2209_writeInt(motorToIC(motor), TMC2209_TCOOLTHRS, *value);
|
||||
}
|
||||
break;
|
||||
case 182:
|
||||
// smartEnergy threshold speed
|
||||
if(readWrite == READ) {
|
||||
buffer = tmc2209_readInt(motorToIC(motor), TMC2209_TCOOLTHRS);
|
||||
*value = MIN(0xFFFFF, (1<<24) / ((buffer) ? buffer : 1));
|
||||
} else if(readWrite == WRITE) {
|
||||
*value = MIN(0xFFFFF, (1<<24) / ((*value) ? *value : 1));
|
||||
tmc2209_writeInt(motorToIC(motor), TMC2209_TCOOLTHRS, *value);
|
||||
}
|
||||
break;
|
||||
case 186:
|
||||
// PWM threshold speed
|
||||
if(readWrite == READ) {
|
||||
buffer = tmc2209_readInt(motorToIC(motor), TMC2209_TPWMTHRS);
|
||||
*value = MIN(0xFFFFF, (1<<24) / ((buffer) ? buffer : 1));
|
||||
} else if(readWrite == WRITE) {
|
||||
*value = MIN(0xFFFFF, (1<<24) / ((*value) ? *value : 1));
|
||||
tmc2209_writeInt(motorToIC(motor), TMC2209_TPWMTHRS, *value);
|
||||
}
|
||||
break;
|
||||
case 187:
|
||||
// PWM gradient
|
||||
if(readWrite == READ) {
|
||||
*value = TMC2209_FIELD_READ(motorToIC(motor), TMC2209_PWMCONF, TMC2209_PWM_GRAD_MASK, TMC2209_PWM_GRAD_SHIFT);
|
||||
} else if(readWrite == WRITE) {
|
||||
// Set gradient
|
||||
TMC2209_FIELD_UPDATE(motorToIC(motor), TMC2209_PWMCONF, TMC2209_PWM_GRAD_MASK, TMC2209_PWM_GRAD_SHIFT, *value);
|
||||
|
||||
// Enable/disable stealthChop accordingly
|
||||
TMC2209_FIELD_UPDATE(motorToIC(motor), TMC2209_GCONF, TMC2209_EN_SPREADCYCLE_MASK, TMC2209_EN_SPREADCYCLE_SHIFT, (*value > 0) ? 0 : 1);
|
||||
}
|
||||
break;
|
||||
case 191:
|
||||
// PWM frequency
|
||||
if(readWrite == READ) {
|
||||
*value = TMC2209_FIELD_READ(motorToIC(motor), TMC2209_PWMCONF, TMC2209_PWM_FREQ_MASK, TMC2209_PWM_FREQ_SHIFT);
|
||||
} else if(readWrite == WRITE) {
|
||||
if(*value >= 0 && *value < 4)
|
||||
{
|
||||
TMC2209_FIELD_UPDATE(motorToIC(motor), TMC2209_PWMCONF, TMC2209_PWM_FREQ_MASK, TMC2209_PWM_FREQ_SHIFT, *value);
|
||||
}
|
||||
else
|
||||
{
|
||||
errors |= TMC_ERROR_VALUE;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case 192:
|
||||
// PWM autoscale
|
||||
if(readWrite == READ) {
|
||||
*value = TMC2209_FIELD_READ(motorToIC(motor), TMC2209_PWMCONF, TMC2209_PWM_AUTOSCALE_MASK, TMC2209_PWM_AUTOSCALE_SHIFT);
|
||||
} else if(readWrite == WRITE) {
|
||||
TMC2209_FIELD_UPDATE(motorToIC(motor), TMC2209_PWMCONF, TMC2209_PWM_AUTOSCALE_MASK, TMC2209_PWM_AUTOSCALE_SHIFT, (*value)? 1:0);
|
||||
}
|
||||
break;
|
||||
case 204:
|
||||
// Freewheeling mode
|
||||
if(readWrite == READ) {
|
||||
*value = TMC2209_FIELD_READ(motorToIC(motor), TMC2209_PWMCONF, TMC2209_FREEWHEEL_MASK, TMC2209_FREEWHEEL_SHIFT);
|
||||
} else if(readWrite == WRITE) {
|
||||
TMC2209_FIELD_UPDATE(motorToIC(motor), TMC2209_PWMCONF, TMC2209_FREEWHEEL_MASK, TMC2209_FREEWHEEL_SHIFT, *value);
|
||||
}
|
||||
break;
|
||||
case 206:
|
||||
// Load value
|
||||
if(readWrite == READ) {
|
||||
*value = tmc2209_readInt(motorToIC(motor), TMC2209_SG_RESULT);
|
||||
} else if(readWrite == WRITE) {
|
||||
errors |= TMC_ERROR_TYPE;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
errors |= TMC_ERROR_TYPE;
|
||||
break;
|
||||
}
|
||||
|
||||
return errors;
|
||||
}
|
||||
|
||||
static uint32_t SAP(uint8_t type, uint8_t motor, int32_t value)
|
||||
{
|
||||
return handleParameter(WRITE, motor, type, &value);
|
||||
}
|
||||
|
||||
static uint32_t GAP(uint8_t type, uint8_t motor, int32_t *value)
|
||||
{
|
||||
return handleParameter(READ, motor, type, value);
|
||||
}
|
||||
|
||||
static void checkErrors(uint32_t tick)
|
||||
{
|
||||
UNUSED(tick);
|
||||
Evalboards.ch2.errors = 0;
|
||||
}
|
||||
|
||||
static uint32_t userFunction(uint8_t type, uint8_t motor, int32_t *value)
|
||||
{
|
||||
uint32_t errors = 0;
|
||||
uint8_t state;
|
||||
IOPinTypeDef *pin;
|
||||
|
||||
switch(type)
|
||||
{
|
||||
case 0: // Read StepDir status bits
|
||||
*value = StepDir_getStatus(motor);
|
||||
break;
|
||||
case 1:
|
||||
tmc2209_set_slave(motorToIC(motor), (*value) & 0xFF);
|
||||
break;
|
||||
case 2:
|
||||
*value = tmc2209_get_slave(motorToIC(motor));
|
||||
break;
|
||||
case 3:
|
||||
*value = Timer.getDuty(timerChannel) * 100 / TIMER_MAX;
|
||||
break;
|
||||
case 4:
|
||||
Timer.setDuty(timerChannel, ((float)*value) / 100);
|
||||
break;
|
||||
case 5: // Set pin state
|
||||
state = (*value) & 0x03;
|
||||
pin = Pins.ENN;
|
||||
switch(motor) {
|
||||
case 0:
|
||||
pin = Pins.ENN;
|
||||
break;
|
||||
case 1:
|
||||
pin = Pins.SPREAD;
|
||||
break;
|
||||
case 2:
|
||||
pin = Pins.MS1_AD0;
|
||||
break;
|
||||
case 3:
|
||||
pin = Pins.MS2_AD1;
|
||||
break;
|
||||
case 4:
|
||||
pin = Pins.UC_PWM;
|
||||
break;
|
||||
case 5:
|
||||
pin = Pins.STDBY;
|
||||
break;
|
||||
}
|
||||
HAL.IOs->config->setToState(pin, state);
|
||||
break;
|
||||
case 6: // Get pin state
|
||||
pin = Pins.ENN;
|
||||
switch(motor) {
|
||||
case 0:
|
||||
pin = Pins.ENN;
|
||||
break;
|
||||
case 1:
|
||||
pin = Pins.SPREAD;
|
||||
break;
|
||||
case 2:
|
||||
pin = Pins.MS1_AD0;
|
||||
break;
|
||||
case 3:
|
||||
pin = Pins.MS2_AD1;
|
||||
break;
|
||||
case 4:
|
||||
pin = Pins.UC_PWM;
|
||||
break;
|
||||
case 5:
|
||||
pin = Pins.STDBY;
|
||||
break;
|
||||
}
|
||||
*value = (uint32_t) HAL.IOs->config->getState(pin);
|
||||
break;
|
||||
default:
|
||||
errors |= TMC_ERROR_TYPE;
|
||||
break;
|
||||
}
|
||||
|
||||
return errors;
|
||||
}
|
||||
|
||||
static void deInit(void)
|
||||
{
|
||||
enableDriver(DRIVER_DISABLE);
|
||||
HAL.IOs->config->reset(Pins.ENN);
|
||||
HAL.IOs->config->reset(Pins.SPREAD);
|
||||
HAL.IOs->config->reset(Pins.STEP);
|
||||
HAL.IOs->config->reset(Pins.DIR);
|
||||
HAL.IOs->config->reset(Pins.MS1_AD0);
|
||||
HAL.IOs->config->reset(Pins.MS2_AD1);
|
||||
HAL.IOs->config->reset(Pins.DIAG);
|
||||
HAL.IOs->config->reset(Pins.INDEX);
|
||||
HAL.IOs->config->reset(Pins.STDBY);
|
||||
HAL.IOs->config->reset(Pins.UC_PWM);
|
||||
|
||||
StepDir_deInit();
|
||||
Timer.deInit();
|
||||
}
|
||||
|
||||
static uint8_t reset()
|
||||
{
|
||||
StepDir_init(STEPDIR_PRECISION);
|
||||
StepDir_setPins(0, Pins.STEP, Pins.DIR, Pins.DIAG);
|
||||
|
||||
return tmc2209_reset(&TMC2209);
|
||||
}
|
||||
|
||||
static uint8_t restore()
|
||||
{
|
||||
return tmc2209_restore(&TMC2209);
|
||||
}
|
||||
|
||||
static void enableDriver(DriverState state)
|
||||
{
|
||||
if(state == DRIVER_USE_GLOBAL_ENABLE)
|
||||
state = Evalboards.driverEnable;
|
||||
|
||||
if(state == DRIVER_DISABLE)
|
||||
HAL.IOs->config->setHigh(Pins.ENN);
|
||||
else if((state == DRIVER_ENABLE) && (Evalboards.driverEnable == DRIVER_ENABLE))
|
||||
HAL.IOs->config->setLow(Pins.ENN);
|
||||
}
|
||||
|
||||
static void periodicJob(uint32_t tick)
|
||||
{
|
||||
tmc2209_periodicJob(&TMC2209, tick);
|
||||
StepDir_periodicJob(0);
|
||||
}
|
||||
|
||||
void TMC2209_init(void)
|
||||
{
|
||||
|
||||
#if defined(Landungsbruecke) || defined(LandungsbrueckeSmall)
|
||||
timerChannel = TIMER_CHANNEL_3;
|
||||
|
||||
#elif defined(LandungsbrueckeV3)
|
||||
timerChannel = TIMER_CHANNEL_4;
|
||||
#endif
|
||||
tmc_fillCRC8Table(0x07, true, 1);
|
||||
thigh = 0;
|
||||
|
||||
Pins.ENN = &HAL.IOs->pins->DIO0;
|
||||
Pins.SPREAD = &HAL.IOs->pins->DIO8;
|
||||
Pins.STEP = &HAL.IOs->pins->DIO6;
|
||||
Pins.DIR = &HAL.IOs->pins->DIO7;
|
||||
Pins.MS1_AD0 = &HAL.IOs->pins->DIO3;
|
||||
Pins.MS2_AD1 = &HAL.IOs->pins->DIO4;
|
||||
Pins.DIAG = &HAL.IOs->pins->DIO1;
|
||||
Pins.INDEX = &HAL.IOs->pins->DIO2;
|
||||
Pins.UC_PWM = &HAL.IOs->pins->DIO9;
|
||||
Pins.STDBY = &HAL.IOs->pins->DIO0;
|
||||
|
||||
HAL.IOs->config->toOutput(Pins.ENN);
|
||||
HAL.IOs->config->toOutput(Pins.SPREAD);
|
||||
HAL.IOs->config->toOutput(Pins.STEP);
|
||||
HAL.IOs->config->toOutput(Pins.DIR);
|
||||
HAL.IOs->config->toOutput(Pins.MS1_AD0);
|
||||
HAL.IOs->config->toOutput(Pins.MS2_AD1);
|
||||
HAL.IOs->config->toInput(Pins.DIAG);
|
||||
HAL.IOs->config->toInput(Pins.INDEX);
|
||||
|
||||
HAL.IOs->config->setLow(Pins.MS1_AD0);
|
||||
HAL.IOs->config->setLow(Pins.MS2_AD1);
|
||||
|
||||
TMC2209_UARTChannel = HAL.UART;
|
||||
TMC2209_UARTChannel->pinout = UART_PINS_2;
|
||||
TMC2209_UARTChannel->rxtx.init();
|
||||
|
||||
TMC2209_config = Evalboards.ch2.config;
|
||||
|
||||
Evalboards.ch2.config->reset = reset;
|
||||
Evalboards.ch2.config->restore = restore;
|
||||
|
||||
Evalboards.ch2.rotate = rotate;
|
||||
Evalboards.ch2.right = right;
|
||||
Evalboards.ch2.left = left;
|
||||
Evalboards.ch2.stop = stop;
|
||||
Evalboards.ch2.GAP = GAP;
|
||||
Evalboards.ch2.SAP = SAP;
|
||||
Evalboards.ch2.moveTo = moveTo;
|
||||
Evalboards.ch2.moveBy = moveBy;
|
||||
Evalboards.ch2.writeRegister = tmc2209_writeRegister;
|
||||
Evalboards.ch2.readRegister = tmc2209_readRegister;
|
||||
Evalboards.ch2.userFunction = userFunction;
|
||||
Evalboards.ch2.enableDriver = enableDriver;
|
||||
Evalboards.ch2.checkErrors = checkErrors;
|
||||
Evalboards.ch2.numberOfMotors = MOTORS;
|
||||
Evalboards.ch2.VMMin = VM_MIN;
|
||||
Evalboards.ch2.VMMax = VM_MAX;
|
||||
Evalboards.ch2.deInit = deInit;
|
||||
Evalboards.ch2.periodicJob = periodicJob;
|
||||
|
||||
tmc2209_init(&TMC2209, 0, 0, TMC2209_config, &tmc2209_defaultRegisterResetState[0]);
|
||||
|
||||
StepDir_init(STEPDIR_PRECISION);
|
||||
StepDir_setPins(0, Pins.STEP, Pins.DIR, Pins.DIAG);
|
||||
StepDir_setVelocityMax(0, 51200);
|
||||
StepDir_setAcceleration(0, 51200);
|
||||
|
||||
HAL.IOs->config->toOutput(Pins.UC_PWM);
|
||||
|
||||
#if defined(Landungsbruecke) || defined(LandungsbrueckeSmall)
|
||||
Pins.UC_PWM->configuration.GPIO_Mode = GPIO_Mode_AF4;
|
||||
#elif defined(LandungsbrueckeV3)
|
||||
Pins.UC_PWM->configuration.GPIO_Mode = GPIO_MODE_AF;
|
||||
gpio_af_set(Pins.UC_PWM->port, GPIO_AF_1, Pins.UC_PWM->bitWeight);
|
||||
|
||||
#endif
|
||||
|
||||
vref = 2000;
|
||||
HAL.IOs->config->set(Pins.UC_PWM);
|
||||
Timer.init();
|
||||
Timer.setDuty(timerChannel, ((float)vref) / VREF_FULLSCALE);
|
||||
|
||||
enableDriver(DRIVER_ENABLE);
|
||||
};
|
||||
Reference in New Issue
Block a user