neurotimer.py 4.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120
  1. import logging
  2. import threading
  3. import time
  4. from kalliope.core.NeuronModule import MissingParameterException, InvalidParameterException
  5. from kalliope.core import NeuronModule
  6. logging.basicConfig()
  7. logger = logging.getLogger("kalliope")
  8. class TimerThread(threading.Thread):
  9. def __init__(self, time_to_wait_seconds, callback):
  10. """
  11. A Thread that will call the given callback method after waiting time_to_wait_seconds
  12. :param time_to_wait_seconds: number of second to wait before call the callback method
  13. :param callback: callback method
  14. """
  15. threading.Thread.__init__(self)
  16. self.time_to_wait_seconds = time_to_wait_seconds
  17. self.callback = callback
  18. def run(self):
  19. # wait the amount of seconds
  20. logger.debug("[Neurotimer] wait %s seconds" % self.time_to_wait_seconds)
  21. time.sleep(self.time_to_wait_seconds)
  22. # then run the callback method
  23. self.callback()
  24. class Neurotimer(NeuronModule):
  25. def __init__(self, **kwargs):
  26. super(Neurotimer, self).__init__(**kwargs)
  27. # get parameters
  28. self.seconds = kwargs.get('seconds', None)
  29. self.minutes = kwargs.get('minutes', None)
  30. self.hours = kwargs.get('hours', None)
  31. self.synapse = kwargs.get('synapse', None)
  32. # do some check
  33. if self._is_parameters_ok():
  34. # make the sum of all time parameter in seconds
  35. retarding_time_seconds = self._get_retarding_time_seconds()
  36. # now wait before running the target synapse
  37. ds = TimerThread(time_to_wait_seconds=retarding_time_seconds, callback=self.callback_run_synapse)
  38. # ds.daemon = True
  39. ds.start()
  40. def _is_parameters_ok(self):
  41. """
  42. Check given neuron parameters are valid
  43. :return: True if the neuron has been well configured
  44. """
  45. # at least one time parameter must be set
  46. if self.seconds is None and self.minutes is None and self.hours is None:
  47. raise MissingParameterException("Neurotimer must have at least one time "
  48. "parameter: seconds, minutes, hours")
  49. self.seconds = self.get_integer_time_parameter(self.seconds)
  50. self.minutes = self.get_integer_time_parameter(self.minutes)
  51. self.hours = self.get_integer_time_parameter(self.hours)
  52. if self.synapse is None:
  53. raise MissingParameterException("Neurotimer must have a synapse name parameter")
  54. return True
  55. @staticmethod
  56. def get_integer_time_parameter(time_parameter):
  57. """
  58. Check if a given time parameter is a valid integer:
  59. - must be > 0
  60. - if type no an integer, must be convertible to integer
  61. :param time_parameter: string or integer
  62. :return: integer
  63. """
  64. if time_parameter is not None:
  65. if not isinstance(time_parameter, int):
  66. # try to convert into integer
  67. try:
  68. time_parameter = int(time_parameter)
  69. except ValueError:
  70. raise InvalidParameterException("[Neurotimer] %s is not a valid integer" % time_parameter)
  71. # check if positive
  72. if time_parameter < 0:
  73. raise InvalidParameterException("[Neurotimer] %s must be > 0" % time_parameter)
  74. return time_parameter
  75. def _get_retarding_time_seconds(self):
  76. """
  77. Return the sum of given time parameters
  78. seconds + minutes + hours
  79. :return: integer, number of total seconds
  80. """
  81. returned_time = 0
  82. if self.seconds is not None:
  83. returned_time += self.seconds
  84. if self.minutes is not None:
  85. returned_time += self.minutes * 60
  86. if self.hours is not None:
  87. returned_time += self.hours * 3600
  88. logger.debug("[Neurotimer] get_retarding_time_seconds: %s" % returned_time)
  89. return returned_time
  90. def callback_run_synapse(self):
  91. """
  92. Callback method which will be started by the timer thread once the time is over
  93. :return:
  94. """
  95. logger.debug("[Neurotimer] waiting time is over, start the synapse %s" % self.synapse)
  96. self.run_synapse_by_name(synapse_name=self.synapse, high_priority=False)