PyTmcStepper 0.7__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Potentially problematic release.
This version of PyTmcStepper might be problematic. Click here for more details.
- pytmcstepper-0.7.dist-info/LICENSE +682 -0
- pytmcstepper-0.7.dist-info/METADATA +302 -0
- pytmcstepper-0.7.dist-info/RECORD +32 -0
- pytmcstepper-0.7.dist-info/WHEEL +5 -0
- pytmcstepper-0.7.dist-info/top_level.txt +1 -0
- tmc_driver/__init__.py +0 -0
- tmc_driver/_tmc_gpio_board.py +321 -0
- tmc_driver/_tmc_logger.py +170 -0
- tmc_driver/_tmc_math.py +102 -0
- tmc_driver/_tmc_stepperdriver.py +278 -0
- tmc_driver/com/__init__.py +0 -0
- tmc_driver/com/_tmc_com.py +155 -0
- tmc_driver/com/_tmc_com_spi.py +177 -0
- tmc_driver/com/_tmc_com_uart.py +336 -0
- tmc_driver/enable_control/__init__.py +0 -0
- tmc_driver/enable_control/_tmc_ec.py +26 -0
- tmc_driver/enable_control/_tmc_ec_pin.py +48 -0
- tmc_driver/enable_control/_tmc_ec_toff.py +39 -0
- tmc_driver/motion_control/__init__.py +0 -0
- tmc_driver/motion_control/_tmc_mc.py +221 -0
- tmc_driver/motion_control/_tmc_mc_step_dir.py +382 -0
- tmc_driver/motion_control/_tmc_mc_step_reg.py +61 -0
- tmc_driver/motion_control/_tmc_mc_vactual.py +179 -0
- tmc_driver/reg/__init__.py +0 -0
- tmc_driver/reg/_tmc2209_reg.py +62 -0
- tmc_driver/reg/_tmc220x_reg.py +198 -0
- tmc_driver/reg/_tmc224x_reg.py +351 -0
- tmc_driver/reg/_tmc_reg.py +121 -0
- tmc_driver/tmc_2208.py +12 -0
- tmc_driver/tmc_2209.py +369 -0
- tmc_driver/tmc_220x.py +684 -0
- tmc_driver/tmc_2240.py +801 -0
|
@@ -0,0 +1,170 @@
|
|
|
1
|
+
#pylint: disable=protected-access
|
|
2
|
+
"""
|
|
3
|
+
Tmc2209 stepper driver logger module
|
|
4
|
+
"""
|
|
5
|
+
|
|
6
|
+
import logging
|
|
7
|
+
from enum import Enum
|
|
8
|
+
|
|
9
|
+
|
|
10
|
+
|
|
11
|
+
class Loglevel(Enum):
|
|
12
|
+
"""loglevel"""
|
|
13
|
+
ALL = 1 # all messages will be logged
|
|
14
|
+
MOVEMENT = 5 # error, warning, info, debug and movement messages will be logged
|
|
15
|
+
DEBUG = 10 # error, warning, info and debug messages will be logged
|
|
16
|
+
INFO = 20 # error, warning and info messages will be logged
|
|
17
|
+
WARNING = 30 # error and warning messages will be logged
|
|
18
|
+
ERROR = 40 # only error messages will be logged
|
|
19
|
+
NONE = -1 # no messages will be logged
|
|
20
|
+
|
|
21
|
+
|
|
22
|
+
|
|
23
|
+
class TmcLogger:
|
|
24
|
+
"""Tmc2209_logger
|
|
25
|
+
|
|
26
|
+
this class has the function:
|
|
27
|
+
log messages from the Tmc2209 lib
|
|
28
|
+
"""
|
|
29
|
+
|
|
30
|
+
_loglevel: Loglevel = Loglevel.INFO
|
|
31
|
+
|
|
32
|
+
|
|
33
|
+
@property
|
|
34
|
+
def loglevel(self):
|
|
35
|
+
"""get the loglevel"""
|
|
36
|
+
return self._loglevel
|
|
37
|
+
|
|
38
|
+
@loglevel.setter
|
|
39
|
+
def loglevel(self, loglevel: Loglevel):
|
|
40
|
+
"""set the loglevel"""
|
|
41
|
+
self._loglevel = loglevel
|
|
42
|
+
self.logger.setLevel(loglevel.value)
|
|
43
|
+
|
|
44
|
+
|
|
45
|
+
def __init__(self,
|
|
46
|
+
loglevel: Loglevel = Loglevel.INFO,
|
|
47
|
+
logprefix: str = "TMC2209",
|
|
48
|
+
handlers: list = None,
|
|
49
|
+
formatter: logging.Formatter = None):
|
|
50
|
+
"""constructor
|
|
51
|
+
|
|
52
|
+
Args:
|
|
53
|
+
logprefix (string): new logprefix (name of the logger) (default: "TMC2209")
|
|
54
|
+
loglevel (enum): level for which to log
|
|
55
|
+
handlers (list): list of logging handlers, see logging.handlers (default: None)
|
|
56
|
+
formatter (logging.Formatter): formatter for the log messages (default: None)
|
|
57
|
+
"""
|
|
58
|
+
if logprefix is None:
|
|
59
|
+
logprefix = "TMC2209"
|
|
60
|
+
|
|
61
|
+
# Add our custom log levels to the logger
|
|
62
|
+
for level in [Loglevel.ALL, Loglevel.MOVEMENT, Loglevel.NONE]:
|
|
63
|
+
self._add_logging_level(level.name, level.value)
|
|
64
|
+
|
|
65
|
+
self.logger = logging.getLogger(logprefix)
|
|
66
|
+
|
|
67
|
+
self.loglevel = loglevel
|
|
68
|
+
if formatter is None:
|
|
69
|
+
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
|
|
70
|
+
self.formatter = formatter
|
|
71
|
+
|
|
72
|
+
if handlers is None:
|
|
73
|
+
# Default handler: StreamHandler (logs to console)
|
|
74
|
+
handlers = [logging.StreamHandler()]
|
|
75
|
+
|
|
76
|
+
for handler in handlers:
|
|
77
|
+
handler.setFormatter(self.formatter)
|
|
78
|
+
self.logger.addHandler(handler)
|
|
79
|
+
|
|
80
|
+
self.logger.propagate = True
|
|
81
|
+
|
|
82
|
+
|
|
83
|
+
def set_logprefix(self, logprefix: str):
|
|
84
|
+
"""set the logprefix.
|
|
85
|
+
|
|
86
|
+
Args:
|
|
87
|
+
logprefix (string): new logprefix
|
|
88
|
+
"""
|
|
89
|
+
self.logger.name = logprefix
|
|
90
|
+
|
|
91
|
+
|
|
92
|
+
def add_handler(self, handler, formatter=None):
|
|
93
|
+
"""add a handler to the logger
|
|
94
|
+
|
|
95
|
+
Args:
|
|
96
|
+
handler (logging.Handler): handler to add
|
|
97
|
+
formatter (logging.Formatter): formatter for the handler,
|
|
98
|
+
or None to use the existing formatter (default: None)
|
|
99
|
+
"""
|
|
100
|
+
if formatter is None:
|
|
101
|
+
formatter = self.formatter
|
|
102
|
+
handler.setFormatter(formatter)
|
|
103
|
+
self.logger.addHandler(handler)
|
|
104
|
+
|
|
105
|
+
|
|
106
|
+
def remove_handler(self, handler):
|
|
107
|
+
"""remove a handler from the logger
|
|
108
|
+
|
|
109
|
+
Args:
|
|
110
|
+
handler (logging.Handler): handler to remove
|
|
111
|
+
"""
|
|
112
|
+
self.logger.removeHandler(handler)
|
|
113
|
+
|
|
114
|
+
|
|
115
|
+
def remove_all_handlers(self):
|
|
116
|
+
"""remove all handlers from the logger"""
|
|
117
|
+
for handler in self.logger.handlers:
|
|
118
|
+
self.logger.removeHandler(handler)
|
|
119
|
+
|
|
120
|
+
|
|
121
|
+
def set_formatter(self, formatter, handlers=None):
|
|
122
|
+
"""set a new formatter for the log messages
|
|
123
|
+
|
|
124
|
+
Args:
|
|
125
|
+
formatter (logging.Formatter): new formatter
|
|
126
|
+
handlers (list): list of logging handlers to set the new formatting for,
|
|
127
|
+
or None to set it for all the handlers
|
|
128
|
+
(default: None)
|
|
129
|
+
"""
|
|
130
|
+
self.formatter = formatter
|
|
131
|
+
if handlers is None:
|
|
132
|
+
handlers = self.logger.handlers
|
|
133
|
+
for handler in handlers:
|
|
134
|
+
handler.setFormatter(formatter)
|
|
135
|
+
|
|
136
|
+
|
|
137
|
+
@staticmethod
|
|
138
|
+
def _add_logging_level(level_name: str, level_num: int, method_name: str = None):
|
|
139
|
+
if not method_name:
|
|
140
|
+
method_name = level_name.lower()
|
|
141
|
+
|
|
142
|
+
# if hasattr(logging, level_name):
|
|
143
|
+
# raise AttributeError(f"{level_name} already defined in logging module")
|
|
144
|
+
# if hasattr(logging, method_name):
|
|
145
|
+
# raise AttributeError(f"{method_name} already defined in logging module")
|
|
146
|
+
# if hasattr(logging.getLoggerClass(), method_name):
|
|
147
|
+
# raise AttributeError(f"{method_name} already defined in logger class")
|
|
148
|
+
|
|
149
|
+
def logForLevel(self, message, *args, **kwargs):
|
|
150
|
+
if self.isEnabledFor(level_num):
|
|
151
|
+
self._log(level_num, message, args, **kwargs)
|
|
152
|
+
|
|
153
|
+
def logToRoot(message, *args, **kwargs):
|
|
154
|
+
logging.log(level_num, message, *args, **kwargs)
|
|
155
|
+
|
|
156
|
+
logging.addLevelName(level_num, level_name)
|
|
157
|
+
setattr(logging, level_name, level_num)
|
|
158
|
+
setattr(logging.getLoggerClass(), method_name, logForLevel)
|
|
159
|
+
setattr(logging, method_name, logToRoot)
|
|
160
|
+
|
|
161
|
+
|
|
162
|
+
def log(self, message, loglevel: Loglevel = Loglevel.INFO):
|
|
163
|
+
"""logs a message
|
|
164
|
+
|
|
165
|
+
Args:
|
|
166
|
+
message (string): message to log
|
|
167
|
+
loglevel (enum): loglevel of this message (Default value = Loglevel.INFO)
|
|
168
|
+
"""
|
|
169
|
+
if self.loglevel is not Loglevel.NONE:
|
|
170
|
+
self.logger.log(loglevel.value, message)
|
tmc_driver/_tmc_math.py
ADDED
|
@@ -0,0 +1,102 @@
|
|
|
1
|
+
"""
|
|
2
|
+
TMC2209_Raspberry_Pi math library
|
|
3
|
+
"""
|
|
4
|
+
|
|
5
|
+
|
|
6
|
+
|
|
7
|
+
def rps_to_vactual(rps, steps_per_rev:int, fclk:int = 12000000) -> int:
|
|
8
|
+
"""converts rps -> vactual
|
|
9
|
+
|
|
10
|
+
Args:
|
|
11
|
+
rps (float): revolutions per second
|
|
12
|
+
steps_per_rev (int): steps per revolution
|
|
13
|
+
fclk (int): clock speed of the tmc (Default value = 12000000)
|
|
14
|
+
|
|
15
|
+
Returns:
|
|
16
|
+
vactual (int): value for vactual
|
|
17
|
+
"""
|
|
18
|
+
return int(round(rps / (fclk / 16777216) * steps_per_rev))
|
|
19
|
+
|
|
20
|
+
|
|
21
|
+
def vactual_to_rps(vactual:int, steps_per_rev:int, fclk:int = 12000000) -> float:
|
|
22
|
+
"""converts vactual -> rps
|
|
23
|
+
|
|
24
|
+
Args:
|
|
25
|
+
vactual (int): value for VACTUAL
|
|
26
|
+
steps_per_rev (int): steps per revolution
|
|
27
|
+
fclk (int): clock speed of the tmc (Default value = 12000000)
|
|
28
|
+
|
|
29
|
+
Returns:
|
|
30
|
+
rps (float): revolutions per second
|
|
31
|
+
"""
|
|
32
|
+
return vactual * (fclk / 16777216) / steps_per_rev
|
|
33
|
+
|
|
34
|
+
|
|
35
|
+
def rps_to_steps(rps:float, steps_per_rev:int) -> int:
|
|
36
|
+
"""converts rps -> steps/second
|
|
37
|
+
|
|
38
|
+
Args:
|
|
39
|
+
rps (float): revolutions per second
|
|
40
|
+
steps_per_rev (int): steps per revolution
|
|
41
|
+
|
|
42
|
+
Returns:
|
|
43
|
+
steps (int): steps per second
|
|
44
|
+
"""
|
|
45
|
+
return int(round(rps * steps_per_rev))
|
|
46
|
+
|
|
47
|
+
def steps_to_rps(steps:int, steps_per_rev:int) -> float:
|
|
48
|
+
"""converts steps/second -> rps
|
|
49
|
+
|
|
50
|
+
Args:
|
|
51
|
+
steps (int): speed in steps per second
|
|
52
|
+
steps_per_rev (int): steps per revolution
|
|
53
|
+
|
|
54
|
+
Returns:
|
|
55
|
+
rps (float): revolutions per second
|
|
56
|
+
"""
|
|
57
|
+
return steps / steps_per_rev
|
|
58
|
+
|
|
59
|
+
|
|
60
|
+
def rps_to_tstep(rps:float, steps_per_rev:int, mres:int) -> int:
|
|
61
|
+
"""converts rps -> tstep
|
|
62
|
+
|
|
63
|
+
Args:
|
|
64
|
+
rps (float): revolutions per second
|
|
65
|
+
steps_per_rev (int): steps per revolution
|
|
66
|
+
mres (int): µstep resolution
|
|
67
|
+
|
|
68
|
+
Returns:
|
|
69
|
+
tstep (int): time per step
|
|
70
|
+
"""
|
|
71
|
+
return int(round(12000000 / (rps_to_steps(rps, steps_per_rev) * 256 / mres)))
|
|
72
|
+
|
|
73
|
+
|
|
74
|
+
def steps_to_tstep(steps:int, mres:int) -> int:
|
|
75
|
+
"""converts steps/second -> tstep
|
|
76
|
+
|
|
77
|
+
Args:
|
|
78
|
+
steps (int): speed in steps per second
|
|
79
|
+
mres (int): µstep resolution
|
|
80
|
+
|
|
81
|
+
Returns:
|
|
82
|
+
tstep (int): time per step
|
|
83
|
+
"""
|
|
84
|
+
return int(round(12000000 / (steps * 256 / mres)))
|
|
85
|
+
|
|
86
|
+
|
|
87
|
+
def constrain(val:int, min_val:int, max_val:int) -> int:
|
|
88
|
+
"""constrains a value between a min and a max
|
|
89
|
+
|
|
90
|
+
Args:
|
|
91
|
+
val (int): value that should be constrained
|
|
92
|
+
min_val (int): minimum value
|
|
93
|
+
max_val (int): maximum value
|
|
94
|
+
|
|
95
|
+
Returns:
|
|
96
|
+
int: constrained value
|
|
97
|
+
"""
|
|
98
|
+
if val < min_val:
|
|
99
|
+
return min_val
|
|
100
|
+
if val > max_val:
|
|
101
|
+
return max_val
|
|
102
|
+
return val
|
|
@@ -0,0 +1,278 @@
|
|
|
1
|
+
#pylint: disable=too-many-arguments
|
|
2
|
+
#pylint: disable=too-many-public-methods
|
|
3
|
+
#pylint: disable=too-many-branches
|
|
4
|
+
#pylint: disable=too-many-positional-arguments
|
|
5
|
+
#pylint: disable=import-outside-toplevel
|
|
6
|
+
#pylint: disable=bare-except
|
|
7
|
+
#pylint: disable=unused-import
|
|
8
|
+
"""TmcStepperDriver module
|
|
9
|
+
|
|
10
|
+
this module has the function to move the motor via STEP/DIR pins
|
|
11
|
+
"""
|
|
12
|
+
|
|
13
|
+
import logging
|
|
14
|
+
from ._tmc_gpio_board import Gpio, GpioMode, Board, BOARD, tmc_gpio
|
|
15
|
+
from .motion_control._tmc_mc import TmcMotionControl, MovementAbsRel, MovementPhase, StopMode, Direction
|
|
16
|
+
from .enable_control._tmc_ec import TmcEnableControl
|
|
17
|
+
from .enable_control._tmc_ec_pin import TmcEnableControlPin
|
|
18
|
+
from .motion_control._tmc_mc_step_dir import TmcMotionControlStepDir
|
|
19
|
+
from ._tmc_logger import TmcLogger, Loglevel
|
|
20
|
+
from . import _tmc_math as tmc_math
|
|
21
|
+
|
|
22
|
+
|
|
23
|
+
|
|
24
|
+
class TmcStepperDriver:
|
|
25
|
+
"""TmcStepperDriver
|
|
26
|
+
|
|
27
|
+
this class has two different functions:
|
|
28
|
+
1. change setting in the TMC-driver via UART
|
|
29
|
+
2. move the motor via STEP/DIR pins
|
|
30
|
+
"""
|
|
31
|
+
|
|
32
|
+
BOARD:Board = BOARD
|
|
33
|
+
tmc_mc:TmcMotionControl = None
|
|
34
|
+
tmc_ec:TmcEnableControl = None
|
|
35
|
+
tmc_logger:TmcLogger = None
|
|
36
|
+
|
|
37
|
+
|
|
38
|
+
_deinit_finished:bool = False
|
|
39
|
+
|
|
40
|
+
|
|
41
|
+
|
|
42
|
+
# Constructor/Destructor
|
|
43
|
+
# ----------------------------
|
|
44
|
+
def __init__(self,
|
|
45
|
+
tmc_ec:TmcEnableControl,
|
|
46
|
+
tmc_mc:TmcMotionControl,
|
|
47
|
+
gpio_mode = None,
|
|
48
|
+
loglevel:Loglevel = Loglevel.INFO,
|
|
49
|
+
logprefix:str = None,
|
|
50
|
+
log_handlers:list = None,
|
|
51
|
+
log_formatter:logging.Formatter = None
|
|
52
|
+
):
|
|
53
|
+
"""constructor
|
|
54
|
+
|
|
55
|
+
Args:
|
|
56
|
+
pin_en (int): EN pin number
|
|
57
|
+
pin_step (int, optional): STEP pin number. Defaults to -1.
|
|
58
|
+
pin_dir (int, optional): DIR pin number. Defaults to -1.
|
|
59
|
+
tmc_com (TmcUart, optional): TMC UART object. Defaults to None.
|
|
60
|
+
driver_address (int, optional): driver address [0-3]. Defaults to 0.
|
|
61
|
+
gpio_mode (enum, optional): gpio mode. Defaults to None.
|
|
62
|
+
loglevel (enum, optional): loglevel. Defaults to None.
|
|
63
|
+
logprefix (str, optional): log prefix (name of the logger).
|
|
64
|
+
Defaults to None (standard TMC prefix).
|
|
65
|
+
log_handlers (list, optional): list of logging handlers.
|
|
66
|
+
Defaults to None (log to console).
|
|
67
|
+
log_formatter (logging.Formatter, optional): formatter for the log messages.
|
|
68
|
+
Defaults to None (messages are logged in the format
|
|
69
|
+
'%(asctime)s - %(name)s - %(levelname)s - %(message)s').
|
|
70
|
+
"""
|
|
71
|
+
if logprefix is None:
|
|
72
|
+
logprefix = "StepperDriver"
|
|
73
|
+
self.tmc_logger = TmcLogger(loglevel, logprefix, log_handlers, log_formatter)
|
|
74
|
+
|
|
75
|
+
self.tmc_logger.log("Init", Loglevel.INFO)
|
|
76
|
+
|
|
77
|
+
tmc_gpio.init(gpio_mode)
|
|
78
|
+
|
|
79
|
+
if tmc_mc is not None:
|
|
80
|
+
self.tmc_mc = tmc_mc
|
|
81
|
+
self.tmc_mc.init(self.tmc_logger)
|
|
82
|
+
|
|
83
|
+
if tmc_ec is not None:
|
|
84
|
+
self.tmc_ec = tmc_ec
|
|
85
|
+
self.tmc_ec.init(self.tmc_logger)
|
|
86
|
+
|
|
87
|
+
self.tmc_logger.log("GPIO Init finished", Loglevel.INFO)
|
|
88
|
+
|
|
89
|
+
|
|
90
|
+
|
|
91
|
+
self.tmc_logger.log("Init finished", Loglevel.INFO)
|
|
92
|
+
|
|
93
|
+
|
|
94
|
+
|
|
95
|
+
def __del__(self):
|
|
96
|
+
"""destructor"""
|
|
97
|
+
if self._deinit_finished is False:
|
|
98
|
+
self.tmc_logger.log("Deinit", Loglevel.INFO)
|
|
99
|
+
|
|
100
|
+
self.set_motor_enabled(False)
|
|
101
|
+
|
|
102
|
+
self.tmc_logger.log("Deinit finished", Loglevel.INFO)
|
|
103
|
+
self._deinit_finished= True
|
|
104
|
+
else:
|
|
105
|
+
self.tmc_logger.log("Deinit already finished", Loglevel.INFO)
|
|
106
|
+
if self.tmc_ec is not None:
|
|
107
|
+
del self.tmc_ec
|
|
108
|
+
if self.tmc_mc is not None:
|
|
109
|
+
del self.tmc_mc
|
|
110
|
+
if self.tmc_logger is not None:
|
|
111
|
+
del self.tmc_logger
|
|
112
|
+
|
|
113
|
+
|
|
114
|
+
# TmcEnableControl Wrapper
|
|
115
|
+
# ----------------------------
|
|
116
|
+
def set_motor_enabled(self, en:bool):
|
|
117
|
+
"""enable control wrapper"""
|
|
118
|
+
if self.tmc_ec is not None:
|
|
119
|
+
self.tmc_ec.set_motor_enabled(en)
|
|
120
|
+
|
|
121
|
+
|
|
122
|
+
# TmcMotionControl Wrapper
|
|
123
|
+
# ----------------------------
|
|
124
|
+
@property
|
|
125
|
+
def current_pos(self):
|
|
126
|
+
"""_current_pos property"""
|
|
127
|
+
if self.tmc_mc is not None:
|
|
128
|
+
return self.tmc_mc.current_pos
|
|
129
|
+
return None
|
|
130
|
+
|
|
131
|
+
@current_pos.setter
|
|
132
|
+
def current_pos(self, current_pos:int):
|
|
133
|
+
"""_current_pos setter"""
|
|
134
|
+
if self.tmc_mc is not None:
|
|
135
|
+
self.tmc_mc.current_pos = current_pos
|
|
136
|
+
|
|
137
|
+
@property
|
|
138
|
+
def mres(self):
|
|
139
|
+
"""_mres property"""
|
|
140
|
+
if self.tmc_mc is not None:
|
|
141
|
+
return self.tmc_mc.mres
|
|
142
|
+
return None
|
|
143
|
+
|
|
144
|
+
@mres.setter
|
|
145
|
+
def mres(self, mres:int):
|
|
146
|
+
"""_mres setter"""
|
|
147
|
+
if self.tmc_mc is not None:
|
|
148
|
+
self.tmc_mc.mres = mres
|
|
149
|
+
|
|
150
|
+
@property
|
|
151
|
+
def steps_per_rev(self):
|
|
152
|
+
"""_steps_per_rev property"""
|
|
153
|
+
if self.tmc_mc is not None:
|
|
154
|
+
return self.tmc_mc.steps_per_rev
|
|
155
|
+
return None
|
|
156
|
+
|
|
157
|
+
@property
|
|
158
|
+
def fullsteps_per_rev(self):
|
|
159
|
+
"""_fullsteps_per_rev property"""
|
|
160
|
+
if self.tmc_mc is not None:
|
|
161
|
+
return self.tmc_mc.fullsteps_per_rev
|
|
162
|
+
return None
|
|
163
|
+
|
|
164
|
+
@fullsteps_per_rev.setter
|
|
165
|
+
def fullsteps_per_rev(self, fullsteps_per_rev:int):
|
|
166
|
+
"""_fullsteps_per_rev setter"""
|
|
167
|
+
if self.tmc_mc is not None:
|
|
168
|
+
self.tmc_mc.fullsteps_per_rev = fullsteps_per_rev
|
|
169
|
+
|
|
170
|
+
@property
|
|
171
|
+
def movement_abs_rel(self):
|
|
172
|
+
"""_movement_abs_rel property"""
|
|
173
|
+
if self.tmc_mc is not None:
|
|
174
|
+
return self.tmc_mc.movement_abs_rel
|
|
175
|
+
return None
|
|
176
|
+
|
|
177
|
+
@movement_abs_rel.setter
|
|
178
|
+
def movement_abs_rel(self, movement_abs_rel:MovementAbsRel):
|
|
179
|
+
"""_movement_abs_rel setter"""
|
|
180
|
+
if self.tmc_mc is not None:
|
|
181
|
+
self.tmc_mc.movement_abs_rel = movement_abs_rel
|
|
182
|
+
|
|
183
|
+
@property
|
|
184
|
+
def movement_phase(self):
|
|
185
|
+
"""_movement_phase property"""
|
|
186
|
+
if self.tmc_mc is not None:
|
|
187
|
+
return self.tmc_mc.movement_phase
|
|
188
|
+
return None
|
|
189
|
+
|
|
190
|
+
@property
|
|
191
|
+
def speed(self):
|
|
192
|
+
"""_speed property"""
|
|
193
|
+
if self.tmc_mc is not None:
|
|
194
|
+
return self.tmc_mc.speed
|
|
195
|
+
return None
|
|
196
|
+
|
|
197
|
+
@speed.setter
|
|
198
|
+
def speed(self, speed:int):
|
|
199
|
+
"""_speed setter"""
|
|
200
|
+
if self.tmc_mc is not None:
|
|
201
|
+
self.tmc_mc.speed = speed
|
|
202
|
+
|
|
203
|
+
@property
|
|
204
|
+
def max_speed(self):
|
|
205
|
+
"""_max_speed property"""
|
|
206
|
+
if self.tmc_mc is not None:
|
|
207
|
+
return self.tmc_mc.max_speed
|
|
208
|
+
return None
|
|
209
|
+
|
|
210
|
+
@max_speed.setter
|
|
211
|
+
def max_speed(self, speed:int):
|
|
212
|
+
"""_max_speed setter"""
|
|
213
|
+
if self.tmc_mc is not None:
|
|
214
|
+
self.tmc_mc.max_speed = speed
|
|
215
|
+
|
|
216
|
+
@property
|
|
217
|
+
def max_speed_fullstep(self):
|
|
218
|
+
"""_max_speed_fullstep property"""
|
|
219
|
+
if self.tmc_mc is not None:
|
|
220
|
+
return self.tmc_mc.max_speed_fullstep
|
|
221
|
+
return None
|
|
222
|
+
|
|
223
|
+
@max_speed_fullstep.setter
|
|
224
|
+
def max_speed_fullstep(self, max_speed_fullstep:int):
|
|
225
|
+
"""_max_speed_fullstep setter"""
|
|
226
|
+
if self.tmc_mc is not None:
|
|
227
|
+
self.tmc_mc.max_speed_fullstep = max_speed_fullstep
|
|
228
|
+
|
|
229
|
+
@property
|
|
230
|
+
def acceleration(self):
|
|
231
|
+
"""_acceleration property"""
|
|
232
|
+
if self.tmc_mc is not None:
|
|
233
|
+
return self.tmc_mc.acceleration
|
|
234
|
+
return None
|
|
235
|
+
|
|
236
|
+
@acceleration.setter
|
|
237
|
+
def acceleration(self, acceleration:int):
|
|
238
|
+
"""_acceleration setter"""
|
|
239
|
+
if self.tmc_mc is not None:
|
|
240
|
+
self.tmc_mc.acceleration = acceleration
|
|
241
|
+
|
|
242
|
+
@property
|
|
243
|
+
def acceleration_fullstep(self):
|
|
244
|
+
"""_acceleration_fullstep property"""
|
|
245
|
+
if self.tmc_mc is not None:
|
|
246
|
+
return self.tmc_mc.acceleration_fullstep
|
|
247
|
+
return None
|
|
248
|
+
|
|
249
|
+
@acceleration_fullstep.setter
|
|
250
|
+
def acceleration_fullstep(self, acceleration_fullstep:int):
|
|
251
|
+
"""_acceleration_fullstep setter"""
|
|
252
|
+
if self.tmc_mc is not None:
|
|
253
|
+
self.tmc_mc.acceleration_fullstep = acceleration_fullstep
|
|
254
|
+
|
|
255
|
+
|
|
256
|
+
def run_to_position_steps(self, steps, movement_abs_rel:MovementAbsRel = None):
|
|
257
|
+
"""motioncontrol wrapper"""
|
|
258
|
+
if self.tmc_mc is not None:
|
|
259
|
+
self.tmc_mc.run_to_position_steps(steps, movement_abs_rel)
|
|
260
|
+
|
|
261
|
+
|
|
262
|
+
def run_to_position_fullsteps(self, steps, movement_abs_rel:MovementAbsRel = None):
|
|
263
|
+
"""motioncontrol wrapper"""
|
|
264
|
+
self.run_to_position_steps(steps * self.mres, movement_abs_rel)
|
|
265
|
+
|
|
266
|
+
|
|
267
|
+
def run_to_position_revolutions(self, revs, movement_abs_rel:MovementAbsRel = None):
|
|
268
|
+
"""motioncontrol wrapper"""
|
|
269
|
+
self.run_to_position_steps(revs * self.steps_per_rev, movement_abs_rel)
|
|
270
|
+
|
|
271
|
+
|
|
272
|
+
# StepperDriver methods
|
|
273
|
+
# ----------------------------
|
|
274
|
+
def test_step(self):
|
|
275
|
+
"""test method"""
|
|
276
|
+
for _ in range(100):
|
|
277
|
+
self.tmc_mc.set_direction(Direction.CW)
|
|
278
|
+
self.tmc_mc.make_a_step()
|
|
File without changes
|
|
@@ -0,0 +1,155 @@
|
|
|
1
|
+
#pylint: disable=import-error
|
|
2
|
+
#pylint: disable=broad-exception-caught
|
|
3
|
+
#pylint: disable=unused-import
|
|
4
|
+
"""
|
|
5
|
+
TmcCom stepper driver communication module
|
|
6
|
+
"""
|
|
7
|
+
|
|
8
|
+
import time
|
|
9
|
+
import struct
|
|
10
|
+
from typing import List
|
|
11
|
+
from .._tmc_logger import TmcLogger, Loglevel
|
|
12
|
+
|
|
13
|
+
|
|
14
|
+
def compute_crc8_atm(datagram, initial_value=0):
|
|
15
|
+
"""this function calculates the crc8 parity bit
|
|
16
|
+
|
|
17
|
+
Args:
|
|
18
|
+
datagram (list): datagram
|
|
19
|
+
initial_value (int): initial value (Default value = 0)
|
|
20
|
+
"""
|
|
21
|
+
crc = initial_value
|
|
22
|
+
# Iterate bytes in data
|
|
23
|
+
for byte in datagram:
|
|
24
|
+
# Iterate bits in byte
|
|
25
|
+
for _ in range(0, 8):
|
|
26
|
+
if (crc >> 7) ^ (byte & 0x01):
|
|
27
|
+
crc = ((crc << 1) ^ 0x07) & 0xFF
|
|
28
|
+
else:
|
|
29
|
+
crc = (crc << 1) & 0xFF
|
|
30
|
+
# Shift to next bit
|
|
31
|
+
byte = byte >> 1
|
|
32
|
+
return crc
|
|
33
|
+
|
|
34
|
+
|
|
35
|
+
|
|
36
|
+
class TmcCom:
|
|
37
|
+
"""TmcCom
|
|
38
|
+
"""
|
|
39
|
+
_tmc_logger:TmcLogger = None
|
|
40
|
+
_tmc_registers = None
|
|
41
|
+
|
|
42
|
+
mtr_id:int = 0
|
|
43
|
+
r_frame:List[int]
|
|
44
|
+
w_frame:List[int]
|
|
45
|
+
communication_pause:int = 0
|
|
46
|
+
error_handler_running:bool = False
|
|
47
|
+
|
|
48
|
+
@property
|
|
49
|
+
def tmc_logger(self):
|
|
50
|
+
"""get the tmc_logger"""
|
|
51
|
+
return self._tmc_logger
|
|
52
|
+
|
|
53
|
+
@tmc_logger.setter
|
|
54
|
+
def tmc_logger(self, tmc_logger):
|
|
55
|
+
"""set the tmc_logger"""
|
|
56
|
+
self._tmc_logger = tmc_logger
|
|
57
|
+
|
|
58
|
+
@property
|
|
59
|
+
def tmc_registers(self):
|
|
60
|
+
"""get the tmc_registers"""
|
|
61
|
+
return self._tmc_registers
|
|
62
|
+
|
|
63
|
+
@tmc_registers.setter
|
|
64
|
+
def tmc_registers(self, tmc_registers):
|
|
65
|
+
"""set the tmc_registers"""
|
|
66
|
+
self._tmc_registers = tmc_registers
|
|
67
|
+
|
|
68
|
+
|
|
69
|
+
|
|
70
|
+
def __init__(self,
|
|
71
|
+
mtr_id:int = 0,
|
|
72
|
+
tmc_logger = None
|
|
73
|
+
):
|
|
74
|
+
"""constructor
|
|
75
|
+
|
|
76
|
+
Args:
|
|
77
|
+
_tmc_logger (class): TMCLogger class
|
|
78
|
+
mtr_id (int, optional): driver address [0-3]. Defaults to 0.
|
|
79
|
+
"""
|
|
80
|
+
self._tmc_logger = tmc_logger
|
|
81
|
+
self.mtr_id = mtr_id
|
|
82
|
+
|
|
83
|
+
|
|
84
|
+
# def init(self):
|
|
85
|
+
# """init"""
|
|
86
|
+
|
|
87
|
+
|
|
88
|
+
# def __del__(self):
|
|
89
|
+
# """destructor"""
|
|
90
|
+
|
|
91
|
+
|
|
92
|
+
def read_reg(self, addr:hex):
|
|
93
|
+
"""reads the registry on the TMC with a given address.
|
|
94
|
+
returns the binary value of that register
|
|
95
|
+
|
|
96
|
+
Args:
|
|
97
|
+
addr (int): HEX, which register to read
|
|
98
|
+
"""
|
|
99
|
+
raise NotImplementedError
|
|
100
|
+
|
|
101
|
+
|
|
102
|
+
def read_int(self, addr:hex, tries:int = 10):
|
|
103
|
+
"""this function tries to read the registry of the TMC 10 times
|
|
104
|
+
if a valid answer is returned, this function returns it as an integer
|
|
105
|
+
|
|
106
|
+
Args:
|
|
107
|
+
addr (int): HEX, which register to read
|
|
108
|
+
tries (int): how many tries, before error is raised (Default value = 10)
|
|
109
|
+
"""
|
|
110
|
+
raise NotImplementedError
|
|
111
|
+
|
|
112
|
+
|
|
113
|
+
def write_reg(self, addr:hex, val:int):
|
|
114
|
+
"""this function can write a value to the register of the tmc
|
|
115
|
+
1. use read_int to get the current setting of the TMC
|
|
116
|
+
2. then modify the settings as wished
|
|
117
|
+
3. write them back to the driver with this function
|
|
118
|
+
|
|
119
|
+
Args:
|
|
120
|
+
addr (int): HEX, which register to write
|
|
121
|
+
val (int): value for that register
|
|
122
|
+
"""
|
|
123
|
+
raise NotImplementedError
|
|
124
|
+
|
|
125
|
+
|
|
126
|
+
def write_reg_check(self, addr:hex, val:int, tries:int=10):
|
|
127
|
+
"""this function als writes a value to the register of the TMC
|
|
128
|
+
but it also checks if the writing process was successfully by checking
|
|
129
|
+
the InterfaceTransmissionCounter before and after writing
|
|
130
|
+
|
|
131
|
+
Args:
|
|
132
|
+
addr: HEX, which register to write
|
|
133
|
+
val: value for that register
|
|
134
|
+
tries: how many tries, before error is raised (Default value = 10)
|
|
135
|
+
"""
|
|
136
|
+
raise NotImplementedError
|
|
137
|
+
|
|
138
|
+
|
|
139
|
+
def flush_serial_buffer(self):
|
|
140
|
+
"""this function clear the communication buffers of the Raspberry Pi"""
|
|
141
|
+
raise NotImplementedError
|
|
142
|
+
|
|
143
|
+
|
|
144
|
+
def handle_error(self):
|
|
145
|
+
"""error handling"""
|
|
146
|
+
raise NotImplementedError
|
|
147
|
+
|
|
148
|
+
|
|
149
|
+
def test_com(self, addr):
|
|
150
|
+
"""test com connection
|
|
151
|
+
|
|
152
|
+
Args:
|
|
153
|
+
addr (int): HEX, which register to test
|
|
154
|
+
"""
|
|
155
|
+
raise NotImplementedError
|