def _send_periodic_internal(
self,
msgs: Union[Sequence[Message], Message],
period: float,
duration: Optional[float] = None,
) -> can.broadcastmanager.CyclicSendTaskABC:
"""Default implementation of periodic message sending using threading.
Override this method to enable a more efficient backend specific approach.
:param msgs:
Messages to transmit
:param period:
Period in seconds between each message
:param duration:
The duration between sending each message at the given rate. If
no duration is provided, the task will continue indefinitely.
:return:
A started task instance. Note the task can be stopped (and
depending on the backend modified) by calling the :meth:`stop`
method.
"""
if not hasattr(self, "_lock_send_periodic"):
# Create a send lock for this bus, but not for buses which override this method
self._lock_send_periodic = ( # pylint: disable=attribute-defined-outside-init
threading.Lock())
task = ThreadBasedCyclicSendTask(self, self._lock_send_periodic, msgs,
period, duration)
return task
def send_periodic(self, msg, period, duration=None):
"""Start sending a message at a given period on this bus.
:param can.Message msg:
Message to transmit
:param float period:
Period in seconds between each message
:param float duration:
The duration to keep sending this message at given rate. If
no duration is provided, the task will continue indefinitely.
:return: A started task instance
:rtype: can.CyclicSendTaskABC
Note the duration before the message stops being sent may not
be exactly the same as the duration specified by the user. In
general the message will be sent at the given rate until at
least *duration* seconds.
"""
if not hasattr(self, "_lock"):
# Create send lock for this bus
self._lock = threading.Lock()
return ThreadBasedCyclicSendTask(self, self._lock, msg, period,
duration)