PyTmcStepper 0.15.0__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.
- pytmcstepper-0.15.0.dist-info/METADATA +338 -0
- pytmcstepper-0.15.0.dist-info/RECORD +56 -0
- pytmcstepper-0.15.0.dist-info/WHEEL +5 -0
- pytmcstepper-0.15.0.dist-info/licenses/LICENSE +683 -0
- pytmcstepper-0.15.0.dist-info/top_level.txt +1 -0
- tmc_driver/__init__.py +96 -0
- tmc_driver/_tmc_exceptions.py +21 -0
- tmc_driver/_tmc_math.py +122 -0
- tmc_driver/_tmc_stallguard.py +340 -0
- tmc_driver/_tmc_stepperdriver.py +210 -0
- tmc_driver/_tmc_validation.py +29 -0
- tmc_driver/_tmc_xxxx.py +489 -0
- tmc_driver/com/__init__.py +64 -0
- tmc_driver/com/_tmc_com.py +148 -0
- tmc_driver/com/_tmc_com_spi.py +81 -0
- tmc_driver/com/_tmc_com_spi_base.py +159 -0
- tmc_driver/com/_tmc_com_spi_ftdi.py +48 -0
- tmc_driver/com/_tmc_com_spi_micropython.py +99 -0
- tmc_driver/com/_tmc_com_uart.py +113 -0
- tmc_driver/com/_tmc_com_uart_base.py +386 -0
- tmc_driver/com/_tmc_com_uart_micropython.py +115 -0
- tmc_driver/enable_control/__init__.py +55 -0
- tmc_driver/enable_control/_tmc_ec.py +59 -0
- tmc_driver/enable_control/_tmc_ec_pin.py +48 -0
- tmc_driver/enable_control/_tmc_ec_toff.py +30 -0
- tmc_driver/motion_control/__init__.py +111 -0
- tmc_driver/motion_control/_tmc_mc.py +280 -0
- tmc_driver/motion_control/_tmc_mc_int_ramp_generator.py +218 -0
- tmc_driver/motion_control/_tmc_mc_step_dir.py +415 -0
- tmc_driver/motion_control/_tmc_mc_step_pwm_dir.py +78 -0
- tmc_driver/motion_control/_tmc_mc_step_reg.py +36 -0
- tmc_driver/motion_control/_tmc_mc_vactual.py +221 -0
- tmc_driver/platform_utils.py +13 -0
- tmc_driver/reg/__init__.py +0 -0
- tmc_driver/reg/_tmc2209_reg.py +55 -0
- tmc_driver/reg/_tmc220x_reg.py +261 -0
- tmc_driver/reg/_tmc224x_reg.py +414 -0
- tmc_driver/reg/_tmc5160_reg.py +526 -0
- tmc_driver/reg/_tmc_reg.py +202 -0
- tmc_driver/reg/_tmc_shared_regs.py +314 -0
- tmc_driver/tmc_2208.py +17 -0
- tmc_driver/tmc_2209.py +75 -0
- tmc_driver/tmc_220x.py +383 -0
- tmc_driver/tmc_2240.py +340 -0
- tmc_driver/tmc_5160.py +344 -0
- tmc_driver/tmc_gpio/__init__.py +101 -0
- tmc_driver/tmc_gpio/_tmc_gpio_board_base.py +106 -0
- tmc_driver/tmc_gpio/_tmc_gpio_board_ftdi.py +162 -0
- tmc_driver/tmc_gpio/_tmc_gpio_board_gpiozero.py +135 -0
- tmc_driver/tmc_gpio/_tmc_gpio_board_micropython.py +108 -0
- tmc_driver/tmc_gpio/_tmc_gpio_board_periphery.py +87 -0
- tmc_driver/tmc_gpio/_tmc_gpio_board_rpi_gpio.py +182 -0
- tmc_driver/tmc_logger/__init__.py +15 -0
- tmc_driver/tmc_logger/_tmc_logger_base.py +111 -0
- tmc_driver/tmc_logger/_tmc_logger_cpython.py +155 -0
- tmc_driver/tmc_logger/_tmc_logger_micropython.py +52 -0
|
@@ -0,0 +1,182 @@
|
|
|
1
|
+
# pylint: disable=wildcard-import
|
|
2
|
+
# pylint: disable=unused-wildcard-import
|
|
3
|
+
# pylint: disable=no-member
|
|
4
|
+
"""
|
|
5
|
+
Many boards have RaspberryPI-compatible PinOut,
|
|
6
|
+
but require to import special GPIO module instead RPI.GPIO
|
|
7
|
+
|
|
8
|
+
This module determines the type of board
|
|
9
|
+
and import the corresponding GPIO module
|
|
10
|
+
|
|
11
|
+
Can be extended to support BeagleBone or other boards
|
|
12
|
+
Supports MicroPython
|
|
13
|
+
"""
|
|
14
|
+
|
|
15
|
+
from importlib import import_module
|
|
16
|
+
from typing import Protocol, Any, runtime_checkable
|
|
17
|
+
from ._tmc_gpio_board_base import *
|
|
18
|
+
|
|
19
|
+
|
|
20
|
+
@runtime_checkable
|
|
21
|
+
class GPIOModuleProtocol(Protocol):
|
|
22
|
+
"""Protocol defining the interface for GPIO modules like RPi.GPIO, Jetson.GPIO, etc."""
|
|
23
|
+
|
|
24
|
+
# pylint: disable=missing-function-docstring
|
|
25
|
+
|
|
26
|
+
BCM: int
|
|
27
|
+
BOARD: int
|
|
28
|
+
IN: int
|
|
29
|
+
OUT: int
|
|
30
|
+
HIGH: int
|
|
31
|
+
LOW: int
|
|
32
|
+
PUD_OFF: int
|
|
33
|
+
PUD_UP: int
|
|
34
|
+
PUD_DOWN: int
|
|
35
|
+
RISING: int
|
|
36
|
+
|
|
37
|
+
class PWM:
|
|
38
|
+
"""PWM class protocol"""
|
|
39
|
+
|
|
40
|
+
def __init__(self, _channel: int, _frequency: float, /) -> None: ...
|
|
41
|
+
def start(self, _dutycycle: float, /) -> None: ...
|
|
42
|
+
def ChangeDutyCycle(self, _dutycycle: float, /) -> None: ...
|
|
43
|
+
def ChangeFrequency(self, _frequency: float, /) -> None: ...
|
|
44
|
+
def stop(self) -> None: ...
|
|
45
|
+
|
|
46
|
+
def setwarnings(self, value: bool) -> None: ...
|
|
47
|
+
def setmode(self, mode: int) -> None: ...
|
|
48
|
+
def cleanup(self, pin: int | None = None) -> None: ...
|
|
49
|
+
def setup(
|
|
50
|
+
self, pin: int, mode: int, initial: int = 0, pull_up_down: int = 0
|
|
51
|
+
) -> None: ...
|
|
52
|
+
def input(self, pin: int) -> int: ...
|
|
53
|
+
def output(self, pin: int, value: int) -> None: ...
|
|
54
|
+
def add_event_detect(
|
|
55
|
+
self, pin: int, edge: int, callback: Any = None, bouncetime: int = 0
|
|
56
|
+
) -> None: ...
|
|
57
|
+
def remove_event_detect(self, pin: int) -> None: ...
|
|
58
|
+
|
|
59
|
+
|
|
60
|
+
class BaseRPiGPIOWrapper(BaseGPIOWrapper):
|
|
61
|
+
"""RPI.GPIO base wrapper"""
|
|
62
|
+
|
|
63
|
+
def __init__(self, gpio_module: GPIOModuleProtocol):
|
|
64
|
+
"""constructor
|
|
65
|
+
|
|
66
|
+
Args:
|
|
67
|
+
gpio_module: GPIO module conforming to GPIOModuleProtocol (e.g., RPi.GPIO, Jetson.GPIO)
|
|
68
|
+
"""
|
|
69
|
+
self.GPIO: GPIOModuleProtocol = gpio_module
|
|
70
|
+
self._gpios_pwm: list[Any] = [None] * 200
|
|
71
|
+
|
|
72
|
+
def init(self, gpio_mode=None):
|
|
73
|
+
"""initialize GPIO library"""
|
|
74
|
+
self.GPIO.setwarnings(False)
|
|
75
|
+
if gpio_mode is None:
|
|
76
|
+
gpio_mode = self.GPIO.BCM
|
|
77
|
+
self.GPIO.setmode(gpio_mode)
|
|
78
|
+
|
|
79
|
+
def deinit(self):
|
|
80
|
+
"""deinitialize GPIO library"""
|
|
81
|
+
self.GPIO.cleanup()
|
|
82
|
+
|
|
83
|
+
def gpio_setup(
|
|
84
|
+
self,
|
|
85
|
+
pin: int,
|
|
86
|
+
mode: GpioMode,
|
|
87
|
+
initial: Gpio | int = Gpio.LOW,
|
|
88
|
+
pull_up_down: GpioPUD = GpioPUD.PUD_OFF,
|
|
89
|
+
):
|
|
90
|
+
"""setup GPIO pin"""
|
|
91
|
+
if mode == GpioMode.OUT:
|
|
92
|
+
self.GPIO.setup(int(pin), int(mode), initial=int(initial))
|
|
93
|
+
else:
|
|
94
|
+
self.GPIO.setup(int(pin), int(mode), pull_up_down=int(pull_up_down))
|
|
95
|
+
|
|
96
|
+
def gpio_cleanup(self, pin: int):
|
|
97
|
+
"""cleanup GPIO pin"""
|
|
98
|
+
gpio_pwm = self._gpios_pwm[pin]
|
|
99
|
+
|
|
100
|
+
if gpio_pwm is not None:
|
|
101
|
+
gpio_pwm.stop()
|
|
102
|
+
self._gpios_pwm[pin] = None
|
|
103
|
+
self.GPIO.cleanup(pin)
|
|
104
|
+
|
|
105
|
+
def gpio_input(self, pin: int) -> int:
|
|
106
|
+
"""read GPIO pin"""
|
|
107
|
+
return self.GPIO.input(pin)
|
|
108
|
+
|
|
109
|
+
def gpio_output(self, pin: int, value: int):
|
|
110
|
+
"""write GPIO pin"""
|
|
111
|
+
self.GPIO.output(pin, value)
|
|
112
|
+
|
|
113
|
+
def gpio_pwm_setup(self, pin: int, frequency: int = 10, duty_cycle: int = 0):
|
|
114
|
+
"""setup PWM"""
|
|
115
|
+
self.GPIO.setup(pin, int(GpioMode.OUT), initial=int(Gpio.LOW))
|
|
116
|
+
self._gpios_pwm[pin] = self.GPIO.PWM(pin, frequency)
|
|
117
|
+
self._gpios_pwm[pin].start(duty_cycle)
|
|
118
|
+
|
|
119
|
+
def gpio_pwm_set_frequency(self, pin: int, frequency: int):
|
|
120
|
+
"""set PWM frequency"""
|
|
121
|
+
gpio_pwm = self._gpios_pwm[pin]
|
|
122
|
+
if gpio_pwm is None:
|
|
123
|
+
raise RuntimeError(f"GPIO pin {pin} not configured as PWM")
|
|
124
|
+
gpio_pwm.ChangeFrequency(frequency)
|
|
125
|
+
|
|
126
|
+
def gpio_pwm_set_duty_cycle(self, pin: int, duty_cycle: int):
|
|
127
|
+
"""set PWM duty cycle
|
|
128
|
+
|
|
129
|
+
Args:
|
|
130
|
+
pin (int): pin number
|
|
131
|
+
duty_cycle (int): duty cycle in percent (0-100)
|
|
132
|
+
"""
|
|
133
|
+
gpio_pwm = self._gpios_pwm[pin]
|
|
134
|
+
if gpio_pwm is None:
|
|
135
|
+
raise RuntimeError(f"GPIO pin {pin} not configured as PWM")
|
|
136
|
+
gpio_pwm.ChangeDutyCycle(duty_cycle)
|
|
137
|
+
|
|
138
|
+
def gpio_add_event_detect(self, pin: int, callback: types.FunctionType):
|
|
139
|
+
"""add event detect"""
|
|
140
|
+
self.GPIO.add_event_detect(
|
|
141
|
+
pin, self.GPIO.RISING, callback=callback, bouncetime=300
|
|
142
|
+
)
|
|
143
|
+
|
|
144
|
+
def gpio_remove_event_detect(self, pin: int):
|
|
145
|
+
"""remove event detect"""
|
|
146
|
+
self.GPIO.remove_event_detect(pin)
|
|
147
|
+
|
|
148
|
+
|
|
149
|
+
def create_gpio_wrapper(module_name: str, description: str) -> BaseRPiGPIOWrapper:
|
|
150
|
+
"""Factory function to create a GPIO wrapper with the specified module.
|
|
151
|
+
|
|
152
|
+
Args:
|
|
153
|
+
module_name: Name of the GPIO module to import (e.g., 'RPi.GPIO', 'Jetson.GPIO')
|
|
154
|
+
description: Description for logging (e.g., 'GPIO control', 'GPIO mocking')
|
|
155
|
+
|
|
156
|
+
Returns:
|
|
157
|
+
Configured BaseRPiGPIOWrapper instance
|
|
158
|
+
"""
|
|
159
|
+
gpio_module = import_module(module_name)
|
|
160
|
+
dependencies_logger.log(f"using {module_name} for {description}", Loglevel.INFO)
|
|
161
|
+
return BaseRPiGPIOWrapper(gpio_module)
|
|
162
|
+
|
|
163
|
+
|
|
164
|
+
# Convenience factory functions for each GPIO type
|
|
165
|
+
def MockGPIOWrapper() -> BaseRPiGPIOWrapper:
|
|
166
|
+
"""Create Mock.GPIO wrapper"""
|
|
167
|
+
return create_gpio_wrapper("Mock.GPIO", "GPIO mocking")
|
|
168
|
+
|
|
169
|
+
|
|
170
|
+
def RPiGPIOWrapper() -> BaseRPiGPIOWrapper:
|
|
171
|
+
"""Create RPi.GPIO wrapper"""
|
|
172
|
+
return create_gpio_wrapper("RPi.GPIO", "GPIO control")
|
|
173
|
+
|
|
174
|
+
|
|
175
|
+
def JetsonGPIOWrapper() -> BaseRPiGPIOWrapper:
|
|
176
|
+
"""Create Jetson.GPIO wrapper"""
|
|
177
|
+
return create_gpio_wrapper("Jetson.GPIO", "GPIO control")
|
|
178
|
+
|
|
179
|
+
|
|
180
|
+
def OPiGPIOWrapper() -> BaseRPiGPIOWrapper:
|
|
181
|
+
"""Create OPi.GPIO wrapper"""
|
|
182
|
+
return create_gpio_wrapper("OPi.GPIO", "GPIO control")
|
|
@@ -0,0 +1,15 @@
|
|
|
1
|
+
# pylint: disable=unused-import
|
|
2
|
+
"""
|
|
3
|
+
Tmc logger module
|
|
4
|
+
"""
|
|
5
|
+
|
|
6
|
+
import sys
|
|
7
|
+
from ._tmc_logger_base import Loglevel
|
|
8
|
+
|
|
9
|
+
MICROPYTHON = sys.implementation.name == "micropython"
|
|
10
|
+
|
|
11
|
+
if MICROPYTHON:
|
|
12
|
+
from ._tmc_logger_micropython import TmcLogger
|
|
13
|
+
else:
|
|
14
|
+
import logging
|
|
15
|
+
from ._tmc_logger_cpython import TmcLogger
|
|
@@ -0,0 +1,111 @@
|
|
|
1
|
+
"""
|
|
2
|
+
Tmc logger module base
|
|
3
|
+
"""
|
|
4
|
+
|
|
5
|
+
from enum import IntEnum
|
|
6
|
+
from abc import abstractmethod
|
|
7
|
+
|
|
8
|
+
|
|
9
|
+
class Loglevel(IntEnum):
|
|
10
|
+
"""Loglevel"""
|
|
11
|
+
|
|
12
|
+
ALL = 1 # all messages will be logged
|
|
13
|
+
MOVEMENT = 5 # error, warning, info, debug and movement messages will be logged
|
|
14
|
+
DEBUG = 10 # error, warning, info and debug messages will be logged
|
|
15
|
+
INFO = 20 # error, warning and info messages will be logged
|
|
16
|
+
WARNING = 30 # error and warning messages will be logged
|
|
17
|
+
ERROR = 40 # only error messages will be logged
|
|
18
|
+
NONE = -1 # no messages will be logged
|
|
19
|
+
|
|
20
|
+
|
|
21
|
+
class TmcLoggerBase:
|
|
22
|
+
"""Tmc2209_logger
|
|
23
|
+
|
|
24
|
+
this class has the function:
|
|
25
|
+
log messages from the Tmc2209 lib
|
|
26
|
+
"""
|
|
27
|
+
|
|
28
|
+
@property
|
|
29
|
+
def loglevel(self):
|
|
30
|
+
"""get the loglevel"""
|
|
31
|
+
return self._loglevel
|
|
32
|
+
|
|
33
|
+
@loglevel.setter
|
|
34
|
+
def loglevel(self, loglevel: Loglevel):
|
|
35
|
+
"""set the loglevel"""
|
|
36
|
+
self._loglevel = loglevel
|
|
37
|
+
|
|
38
|
+
@property
|
|
39
|
+
def logprefix(self):
|
|
40
|
+
"""get the logprefix"""
|
|
41
|
+
return self._logprefix
|
|
42
|
+
|
|
43
|
+
@logprefix.setter
|
|
44
|
+
def logprefix(self, logprefix: str):
|
|
45
|
+
"""set the logprefix"""
|
|
46
|
+
self._logprefix = logprefix
|
|
47
|
+
|
|
48
|
+
def __init__(
|
|
49
|
+
self,
|
|
50
|
+
loglevel: Loglevel = Loglevel.INFO,
|
|
51
|
+
logprefix: str = "TMCXXXX",
|
|
52
|
+
):
|
|
53
|
+
"""constructor
|
|
54
|
+
|
|
55
|
+
Args:
|
|
56
|
+
loglevel (enum): level for which to log
|
|
57
|
+
logprefix (string): new logprefix (name of the logger) (default: "TMCXXXX")
|
|
58
|
+
"""
|
|
59
|
+
self.logprefix = logprefix
|
|
60
|
+
self.loglevel = loglevel
|
|
61
|
+
|
|
62
|
+
def __del__(self):
|
|
63
|
+
"""destructor"""
|
|
64
|
+
self.deinit()
|
|
65
|
+
|
|
66
|
+
@abstractmethod
|
|
67
|
+
def deinit(self):
|
|
68
|
+
"""destructor"""
|
|
69
|
+
self.remove_all_handlers()
|
|
70
|
+
|
|
71
|
+
@abstractmethod
|
|
72
|
+
def add_handler(self, handler, formatter=None):
|
|
73
|
+
"""add a handler to the logger
|
|
74
|
+
|
|
75
|
+
Args:
|
|
76
|
+
handler (logging.Handler): handler to add
|
|
77
|
+
formatter (logging.Formatter): formatter for the handler,
|
|
78
|
+
or None to use the existing formatter (default: None)
|
|
79
|
+
"""
|
|
80
|
+
|
|
81
|
+
@abstractmethod
|
|
82
|
+
def remove_handler(self, handler):
|
|
83
|
+
"""remove a handler from the logger
|
|
84
|
+
|
|
85
|
+
Args:
|
|
86
|
+
handler (logging.Handler): handler to remove
|
|
87
|
+
"""
|
|
88
|
+
|
|
89
|
+
@abstractmethod
|
|
90
|
+
def remove_all_handlers(self):
|
|
91
|
+
"""remove all handlers from the logger"""
|
|
92
|
+
|
|
93
|
+
@abstractmethod
|
|
94
|
+
def set_formatter(self, formatter, handlers=None):
|
|
95
|
+
"""set a new formatter for the log messages
|
|
96
|
+
|
|
97
|
+
Args:
|
|
98
|
+
formatter (logging.Formatter): new formatter
|
|
99
|
+
handlers (list): list of logging handlers to set the new formatting for,
|
|
100
|
+
or None to set it for all the handlers
|
|
101
|
+
(default: None)
|
|
102
|
+
"""
|
|
103
|
+
|
|
104
|
+
@abstractmethod
|
|
105
|
+
def log(self, message, loglevel: Loglevel = Loglevel.INFO):
|
|
106
|
+
"""logs a message
|
|
107
|
+
|
|
108
|
+
Args:
|
|
109
|
+
message (string): message to log
|
|
110
|
+
loglevel (enum): loglevel of this message (Default value = Loglevel.INFO)
|
|
111
|
+
"""
|
|
@@ -0,0 +1,155 @@
|
|
|
1
|
+
"""
|
|
2
|
+
Tmc logger module for CPython
|
|
3
|
+
"""
|
|
4
|
+
|
|
5
|
+
import logging
|
|
6
|
+
from ._tmc_logger_base import Loglevel, TmcLoggerBase
|
|
7
|
+
|
|
8
|
+
|
|
9
|
+
class TmcLogger(TmcLoggerBase):
|
|
10
|
+
"""Tmc2209_logger
|
|
11
|
+
|
|
12
|
+
this class has the function:
|
|
13
|
+
log messages from the Tmc2209 lib
|
|
14
|
+
"""
|
|
15
|
+
|
|
16
|
+
@property
|
|
17
|
+
def loglevel(self):
|
|
18
|
+
"""get the loglevel"""
|
|
19
|
+
return self._loglevel
|
|
20
|
+
|
|
21
|
+
@loglevel.setter
|
|
22
|
+
def loglevel(self, loglevel: Loglevel):
|
|
23
|
+
"""set the loglevel"""
|
|
24
|
+
self._loglevel = loglevel
|
|
25
|
+
self.logger.setLevel(int(loglevel))
|
|
26
|
+
|
|
27
|
+
@property
|
|
28
|
+
def logprefix(self):
|
|
29
|
+
"""get the logprefix"""
|
|
30
|
+
return self._logprefix
|
|
31
|
+
|
|
32
|
+
@logprefix.setter
|
|
33
|
+
def logprefix(self, logprefix: str):
|
|
34
|
+
"""set the logprefix"""
|
|
35
|
+
self._logprefix = logprefix
|
|
36
|
+
self.logger.name = logprefix
|
|
37
|
+
|
|
38
|
+
def __init__(
|
|
39
|
+
self,
|
|
40
|
+
loglevel: Loglevel = Loglevel.INFO,
|
|
41
|
+
logprefix: str = "TMCXXXX",
|
|
42
|
+
handlers: list | None = None,
|
|
43
|
+
formatter: logging.Formatter | None = None,
|
|
44
|
+
):
|
|
45
|
+
"""constructor
|
|
46
|
+
|
|
47
|
+
Args:
|
|
48
|
+
loglevel (enum): level for which to log
|
|
49
|
+
logprefix (string): new logprefix (name of the logger) (default: "TMCXXXX")
|
|
50
|
+
handlers (list): list of logging handlers, see logging.handlers (default: None)
|
|
51
|
+
formatter (logging.Formatter): formatter for the log messages (default: None)
|
|
52
|
+
"""
|
|
53
|
+
|
|
54
|
+
# Add our custom log levels to the logger
|
|
55
|
+
for level in [Loglevel.ALL, Loglevel.MOVEMENT, Loglevel.NONE]:
|
|
56
|
+
self._add_logging_level(level.name, int(level))
|
|
57
|
+
|
|
58
|
+
self.logger = logging.getLogger(logprefix)
|
|
59
|
+
|
|
60
|
+
if formatter is None:
|
|
61
|
+
formatter = logging.Formatter(
|
|
62
|
+
"%(asctime)s - %(name)s - %(levelname)s - %(message)s"
|
|
63
|
+
)
|
|
64
|
+
self.formatter = formatter
|
|
65
|
+
|
|
66
|
+
if handlers is None:
|
|
67
|
+
# Default handler: StreamHandler (logs to console)
|
|
68
|
+
handlers = [logging.StreamHandler()]
|
|
69
|
+
|
|
70
|
+
for handler in handlers:
|
|
71
|
+
handler.setFormatter(self.formatter)
|
|
72
|
+
self.logger.addHandler(handler)
|
|
73
|
+
|
|
74
|
+
self.logger.propagate = True
|
|
75
|
+
|
|
76
|
+
super().__init__(loglevel, logprefix)
|
|
77
|
+
|
|
78
|
+
def __del__(self):
|
|
79
|
+
"""destructor"""
|
|
80
|
+
self.deinit()
|
|
81
|
+
|
|
82
|
+
def deinit(self):
|
|
83
|
+
"""destructor"""
|
|
84
|
+
self.remove_all_handlers()
|
|
85
|
+
|
|
86
|
+
def add_handler(self, handler, formatter=None):
|
|
87
|
+
"""add a handler to the logger
|
|
88
|
+
|
|
89
|
+
Args:
|
|
90
|
+
handler (logging.Handler): handler to add
|
|
91
|
+
formatter (logging.Formatter): formatter for the handler,
|
|
92
|
+
or None to use the existing formatter (default: None)
|
|
93
|
+
"""
|
|
94
|
+
if formatter is None:
|
|
95
|
+
formatter = self.formatter
|
|
96
|
+
handler.setFormatter(formatter)
|
|
97
|
+
self.logger.addHandler(handler)
|
|
98
|
+
|
|
99
|
+
def remove_handler(self, handler):
|
|
100
|
+
"""remove a handler from the logger
|
|
101
|
+
|
|
102
|
+
Args:
|
|
103
|
+
handler (logging.Handler): handler to remove
|
|
104
|
+
"""
|
|
105
|
+
self.logger.removeHandler(handler)
|
|
106
|
+
|
|
107
|
+
def remove_all_handlers(self):
|
|
108
|
+
"""remove all handlers from the logger"""
|
|
109
|
+
for handler in self.logger.handlers:
|
|
110
|
+
self.logger.removeHandler(handler)
|
|
111
|
+
|
|
112
|
+
def set_formatter(self, formatter, handlers=None):
|
|
113
|
+
"""set a new formatter for the log messages
|
|
114
|
+
|
|
115
|
+
Args:
|
|
116
|
+
formatter (logging.Formatter): new formatter
|
|
117
|
+
handlers (list): list of logging handlers to set the new formatting for,
|
|
118
|
+
or None to set it for all the handlers
|
|
119
|
+
(default: None)
|
|
120
|
+
"""
|
|
121
|
+
self.formatter = formatter
|
|
122
|
+
if handlers is None:
|
|
123
|
+
handlers = self.logger.handlers
|
|
124
|
+
for handler in handlers:
|
|
125
|
+
handler.setFormatter(formatter)
|
|
126
|
+
|
|
127
|
+
@staticmethod
|
|
128
|
+
def _add_logging_level(
|
|
129
|
+
level_name: str, level_num: int, method_name: str | None = None
|
|
130
|
+
):
|
|
131
|
+
if not method_name:
|
|
132
|
+
method_name = level_name.lower()
|
|
133
|
+
|
|
134
|
+
def logForLevel(self, message, *args, **kwargs):
|
|
135
|
+
if self.isEnabledFor(level_num):
|
|
136
|
+
# pylint: disable=protected-access
|
|
137
|
+
self._log(level_num, message, args, **kwargs)
|
|
138
|
+
|
|
139
|
+
def logToRoot(message, *args, **kwargs):
|
|
140
|
+
logging.log(level_num, message, *args, **kwargs)
|
|
141
|
+
|
|
142
|
+
logging.addLevelName(level_num, level_name)
|
|
143
|
+
setattr(logging, level_name, level_num)
|
|
144
|
+
setattr(logging.getLoggerClass(), method_name, logForLevel)
|
|
145
|
+
setattr(logging, method_name, logToRoot)
|
|
146
|
+
|
|
147
|
+
def log(self, message, loglevel: Loglevel = Loglevel.INFO):
|
|
148
|
+
"""logs a message
|
|
149
|
+
|
|
150
|
+
Args:
|
|
151
|
+
message (string): message to log
|
|
152
|
+
loglevel (enum): loglevel of this message (Default value = Loglevel.INFO)
|
|
153
|
+
"""
|
|
154
|
+
if self.loglevel is not Loglevel.NONE:
|
|
155
|
+
self.logger.log(int(loglevel), message)
|
|
@@ -0,0 +1,52 @@
|
|
|
1
|
+
"""
|
|
2
|
+
Tmc logger module for MicroPython
|
|
3
|
+
"""
|
|
4
|
+
|
|
5
|
+
from ._tmc_logger_base import Loglevel, TmcLoggerBase
|
|
6
|
+
|
|
7
|
+
|
|
8
|
+
class TmcLogger(TmcLoggerBase):
|
|
9
|
+
"""minimal logger for MicroPython"""
|
|
10
|
+
|
|
11
|
+
def __init__(
|
|
12
|
+
self,
|
|
13
|
+
loglevel: Loglevel = Loglevel.INFO,
|
|
14
|
+
logprefix: str = "TMCXXXX",
|
|
15
|
+
handlers=None,
|
|
16
|
+
formatter=None,
|
|
17
|
+
):
|
|
18
|
+
"""constructor
|
|
19
|
+
|
|
20
|
+
Args:
|
|
21
|
+
loglevel (enum): level for which to log
|
|
22
|
+
logprefix (string): new logprefix (name of the logger) (default: "TMCXXXX")
|
|
23
|
+
handlers (list): list of logging handlers, see logging.handlers (default: None)
|
|
24
|
+
formatter (logging.Formatter): formatter for the log messages (default: None)
|
|
25
|
+
"""
|
|
26
|
+
super().__init__(loglevel, logprefix)
|
|
27
|
+
del handlers
|
|
28
|
+
del formatter
|
|
29
|
+
|
|
30
|
+
def __del__(self):
|
|
31
|
+
pass
|
|
32
|
+
|
|
33
|
+
def deinit(self):
|
|
34
|
+
pass
|
|
35
|
+
|
|
36
|
+
def add_handler(self, handler, formatter=None):
|
|
37
|
+
pass
|
|
38
|
+
|
|
39
|
+
def remove_handler(self, handler):
|
|
40
|
+
pass
|
|
41
|
+
|
|
42
|
+
def remove_all_handlers(self):
|
|
43
|
+
pass
|
|
44
|
+
|
|
45
|
+
def set_formatter(self, formatter, handlers=None):
|
|
46
|
+
pass
|
|
47
|
+
|
|
48
|
+
def log(self, message, loglevel=None):
|
|
49
|
+
if self.loglevel is Loglevel.NONE:
|
|
50
|
+
return
|
|
51
|
+
if loglevel is None or self.loglevel is None or loglevel >= self._loglevel:
|
|
52
|
+
print(message)
|