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.

@@ -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)
@@ -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