def callback(self, status, response):
"""
提交资产后的回调函数
:param status: 是否请求成功
:param response: 请求成功，则是响应内容对象；请求错误，则是异常对象
:return:
"""
if not status:
Logger().log(str(response), False)
return
ret = json.loads(response.text)
if ret['code'] == 1000:
Logger().log(ret['message'], True)
else:
Logger().log(ret['message'], False)
def __init__(self, runtime_env, ini_file="config.ini", os=None):
self.logger = Logger(log_level=0, console_level=3)
self.sts = Settings(self.logger, runtime_env, ini_file=ini_file) # sts
self.logger.set_console_level(self.sts.debug_level)
self.logger.set_log_level(0)
self.comfun = CommonFunctions(self.logger)
if os is None:
self.os = platform.system()
if self.os == "Windows":
self.os = "w"
elif self.os == "Linux":
self.os = "l"
else:
self.os = None
# abbreviation for very often used variables, helping with identification the main modules
self.usr = Users(self) # usr
self.prj = Projects(self) # prj
self.sch = Schemas(self) # sch
self.tsk = Tasks(self) # tsk
self.que = Queue(self) # que
self.nod = SimNodes(self) # nod
self.dfn = Definitions(self) # dfn
self.sio = StorageInOut(self) # sio
# abbreviation END
self.logger.inf("SimBatch started")
def __init__(self, config, number, level):
self._number = number
self._log = Logger("servo-{:d}".format(number), level)
self._config = config
if self._config:
self._log.info('configuration provided.')
_config = self._config['ros'].get('servo{:d}'.format(number))
self._center_offset = _config.get('center_offset')
else:
self._log.warning('no configuration provided.')
self._center_offset = 0.0
self._log.info('center offset: {:>3.1f}'.format(self._center_offset))
self._UB = UltraBorg(level) # create a new UltraBorg object
self._UB.Init() # initialise the board (checks it is connected)
# settings .......................................................................
self._min_angle = -90.1 # Smallest position to use (n/90)
self._max_angle = +90.1 # Largest position to use (n/90)
self._startup_delay = 0.5 # Delay before making the initial move
self._step_delay = 0.05 # Delay between steps
self._rate_start = 0.05 # Step distance for all servos during initial move
self._step_distance = 1.0 # Step distance for servo #1
self._enabled = False
self._closed = False
self._log.info('ready.')
def __init__(self, config, queue, level):
if config is None:
raise ValueError('no configuration provided.')
self._config = config['ros'].get('integrated_front_sensor')
self._queue = queue
self._log = Logger("ifs", level)
self._device_id = self._config.get('device_id') # i2c hex address of slave device, must match Arduino's SLAVE_I2C_ADDRESS
self._channel = self._config.get('channel')
# short distance:
self._port_side_trigger_distance = self._config.get('port_side_trigger_distance')
self._port_trigger_distance = self._config.get('port_trigger_distance')
self._center_trigger_distance = self._config.get('center_trigger_distance')
self._stbd_trigger_distance = self._config.get('stbd_trigger_distance')
self._stbd_side_trigger_distance = self._config.get('stbd_side_trigger_distance')
self._log.info('event thresholds:' \
+ Fore.RED + ' port side={:>5.2f}; port={:>5.2f};'.format(self._port_side_trigger_distance, self._port_trigger_distance) \
+ Fore.BLUE + ' center={:>5.2f};'.format(self._center_trigger_distance) \
+ Fore.GREEN + ' stbd={:>5.2f}; stbd side={:>5.2f}'.format(self._stbd_trigger_distance, self._stbd_side_trigger_distance ))
self._loop_delay_sec = self._config.get('loop_delay_sec')
self._log.debug('initialising integrated front sensor...')
self._counter = itertools.count()
self._thread = None
self._enabled = False
self._suppressed = False
self._closing = False
self._closed = False
self._log.info('ready.')
def main():
_log = Logger("logger", Level.INFO, log_to_file=True)
for i in range(10):
_log.file("log message {}".format(i))
print("log message {}".format(i))
def __init__(self,
label,
kp,
ki,
kd,
min_output,
max_output,
setpoint=0.0,
sample_time=0.01,
level=Level.INFO):
self._kp = kp # proportional gain
self._ki = ki # integral gain
self._kd = kd # derivative gain
self._setpoint = setpoint
self._min_output = min_output
self._max_output = max_output
self._limit = None
self._log = Logger('pid:{}'.format(label), level)
if self._min_output is None or self._max_output is None:
self._log.info('kp:{:7.4f}; ki:{:7.4f}; kd:{:7.4f};\tmin={}; max={}'.format(self._kp, self._ki, self._kd, self._min_output, self._max_output))
else:
self._log.info('kp:{:7.4f}; ki:{:7.4f}; kd:{:7.4f};\tmin={:>5.2f}; max={:>5.2f}'.format(self._kp, self._ki, self._kd, self._min_output, self._max_output))
if sample_time is None:
raise Exception('no sample time argument provided')
self._sample_time = sample_time
self._log.info('sample time: {:7.4f} sec'.format(self._sample_time))
self._current_time = time.monotonic # to ensure time deltas are always positive
self.reset()
self._log.info('ready.')
def __init__(self, config, queue, level):
self._log = Logger("nxp9dof", level)
if config is None:
raise ValueError("no configuration provided.")
self._config = config
self._queue = queue
_config = self._config['ros'].get('nxp9dof')
self._quaternion_accept = _config.get(
'quaternion_accept') # permit Quaternion once calibrated
self._loop_delay_sec = _config.get('loop_delay_sec')
# verbose will print some start-up info on the IMU sensors
self._imu = IMU(gs=4, dps=2000, verbose=True)
# setting a bias correction for the accel only; the mags/gyros are not getting a bias correction
self._imu.setBias((0.0, 0.0, 0.0), None, None)
# self._imu.setBias((0.1,-0.02,.25), None, None)
_i2c = busio.I2C(board.SCL, board.SDA)
self._fxos = adafruit_fxos8700.FXOS8700(_i2c)
self._log.info('accelerometer and magnetometer ready.')
self._fxas = adafruit_fxas21002c.FXAS21002C(_i2c)
self._log.info('gyroscope ready.')
self._thread = None
self._enabled = False
self._closed = False
self._heading = None
self._pitch = None
self._roll = None
self._is_calibrated = False
self._log.info('ready.')
def hyperloop():
imageFolder = None
imageNum = 0
logger = Logger('relog')
logger.setLogLevel('debug')
logger.info('Started replay')
state = State()
for p in sys.argv:
if (os.path.isdir(p)):
imageFolder = p
elif (p.isdigit()):
imageNum = int(p)
elif (p == "-lap"):
state.Approaching = Signal.LAP
elif (p == "-up"):
state.Approaching = Signal.UPPER
elif (p == "-lo"):
state.Approaching = Signal.LOWER
elif (p == "-s"):
state.Approaching = Signal.UPPER
if (state.Approaching != Signal.LAP):
state.setStopSignal(1)
camera = Camera(None, True)
if imageFolder:
# program loop
files = sorted_aphanumeric(os.listdir(imageFolder))
while True:
try:
file = os.path.join(imageFolder, files[imageNum])
logger.info("[" + str(imageNum) + "] Loaded file: " + file)
image = cv2.imread(file, 1)
camera.capture(image)
key = cv2.waitKey(0) & 0xFF
if key == ord("n"):
# cv2.destroyAllWindows()
if (imageNum + 1 < len(files)):
imageNum += 1
elif key == ord("b"):
# cv2.destroyAllWindows()
if (imageNum - 1 >= 0):
imageNum -= 1
elif key == ord('q'):
break
except KeyboardInterrupt:
break
except Exception as e:
logger.logError(e)
traceback.print_exc(limit=3, file=sys.stdout)
logger.info('Stopped')
def __init__(
self,
config,
orientation, # used only for logging
setpoint=0.0,
sample_time=0.01,
level=Level.INFO):
if config is None:
raise ValueError('null configuration argument.')
_config = config['ros'].get('motors').get('pid')
self.kp = _config.get('kp') # proportional gain
self.ki = _config.get('ki') # integral gain
self.kd = _config.get('kd') # derivative gain
self._min_output = _config.get('min_output')
self._max_output = _config.get('max_output')
self._setpoint = setpoint
self._orientation = orientation
self._max_velocity = None
self._log = Logger('pid:{}'.format(orientation.label), level)
self._log.info(
'kp:{:7.4f}; ki:{:7.4f}; kd:{:7.4f};\tmin={:>5.2f}; max={:>5.2f}'.
format(self._kp, self.ki, self.kd, self._min_output,
self._max_output))
if sample_time is None:
raise Exception('no sample time argument provided')
self._sample_time = sample_time
self._log.info('sample time: {:7.4f} sec'.format(self._sample_time))
self._current_time = time.monotonic # to ensure time deltas are always positive
self.reset()
self._log.info('ready.')
def __init__(self, config, ifs, motors, callback_shutdown, level):
super().__init__()
if config is None:
raise ValueError("no configuration provided.")
if ifs is None:
raise ValueError("no ifs provided.")
if motors is None:
raise ValueError("no motors provided.")
self._log = Logger('controller', level)
self._config = config
self._enable_self_shutdown = self._config['ros'].get(
'enable_self_shutdown')
# self._switch = switch
self._ifs = ifs
self._motors = motors
self._port_motor = motors.get_motor(Orientation.PORT)
# self._port_pid = self._port_motor.get_pid_controller()
self._stbd_motor = motors.get_motor(Orientation.STBD)
# self._stbd_pid = self._stbd_motor.get_pid_controller()
self._callback_shutdown = callback_shutdown
# self._status = Status(config, GPIO, level)
self._current_message = None
self._standby = False
self._enabled = True
# behaviours .................................
# self._behaviours = Behaviours(motors, ifs, Level.INFO)
# self._roam_behaviour = RoamBehaviour(motors, Level.INFO)
self._log.debug('ready.')
def test_rot_control():
_log = Logger("rot-ctrl-test", Level.INFO)
_rot_ctrl = None
try:
# read YAML configuration
_loader = ConfigLoader(Level.INFO)
filename = 'config.yaml'
_config = _loader.configure(filename)
# def __init__(self, config, minimum, maximum, step, level):
# _min = -127
# _max = 127
# _step = 1
_min = 0
_max = 10
_step = 0.5
_rot_ctrl = RotaryControl(_config, _min, _max, _step, Level.INFO)
_rate = Rate(20)
_log.info(Fore.WHITE + Style.BRIGHT +
'waiting for changes to rotary encoder...')
while True:
_value = _rot_ctrl.read()
_log.info(Fore.YELLOW + ' value: {:5.2f}'.format(_value))
_rate.wait()
finally:
if _rot_ctrl:
_log.info('resetting rotary encoder...')
_rot_ctrl.reset()
def main():
signal.signal(signal.SIGINT, signal_handler)
_log = Logger("infrareds test", Level.INFO)
_log.info('starting test...')
_log.info(Fore.YELLOW + Style.BRIGHT + 'Press Ctrl+C to exit.')
_log.info(Fore.BLUE + Style.BRIGHT +
'to pass test, trigger all infrared sensors...')
# read YAML configuration
_loader = ConfigLoader(Level.INFO)
filename = 'config.yaml'
_config = _loader.configure(filename)
_queue = MockMessageQueue(Level.INFO)
_infrareds = Infrareds(_config, _queue, Level.INFO)
_infrareds.enable()
while not _queue.is_complete():
_queue._display_event_list()
time.sleep(2.0)
_infrareds.close()
_log.info('complete.')
def __init__(self, config, queue, message_factory, level):
'''
Parameters:
config: the YAML-based application configuration
queue: the message queue to receive messages from this task
message_factory: the factory for creating messages
mutex: vs godzilla
'''
if config is None:
raise ValueError('no configuration provided.')
self._level = level
self._log = Logger("gamepad", level)
self._log.info('initialising...')
self._config = config
_config = config['ros'].get('gamepad')
# config
_loop_freq_hz = _config.get('loop_freq_hz')
self._rate = Rate(_loop_freq_hz)
self._device_path = _config.get('device_path')
self._queue = queue
self._message_factory = message_factory
self._gamepad_closed = False
self._closed = False
self._enabled = False
self._thread = None
self._gamepad = None
def __init__(self, level):
self._log = Logger("bus", level)
if level is Level.DEBUG:
self._log.debug(Fore.YELLOW + 'logging message bus set to debug level.')
logging.basicConfig(level=logging.DEBUG)
self._loop = asyncio.get_event_loop()
self._queue = asyncio.Queue()
self._publishers = []
self._subscribers = []
# may want to catch other signals too
signals = (signal.SIGHUP, signal.SIGTERM, signal.SIGINT)
for s in signals:
self._loop.add_signal_handler(
s, lambda s = s: asyncio.create_task(self.shutdown(s)))
self._loop.set_exception_handler(self.handle_exception)
self._garbage_collector = GarbageCollector('gc', Fore.RED, self, Level.INFO)
self.register_subscriber(self._garbage_collector)
self._max_age = 5.0 # ms
self._verbose = True
self._enabled = True # by default
self._closed = False
self._log.info('creating subscriber task...')
self._loop.create_task(self.start_consuming())
self._log.info('ready.')
def __init__(self, config, level):
self._log = Logger('follower', Level.INFO)
self._config = config
if self._config:
self._log.info('configuration provided.')
_config = self._config['ros'].get('wall_follower')
self._port_angle = _config.get('port_angle')
self._stbd_angle = _config.get('starboard_angle')
_range_value = _config.get('tof_range')
_range = Range.from_str(_range_value)
_servo_number = _config.get('servo_number')
else:
self._log.warning('no configuration provided.')
self._port_angle = -90.0
self._stbd_angle = 90.0
_range = Range.PERFORMANCE
_servo_number = 2
# _range = Range.LONG
# _range = Range.MEDIUM
# _range = Range.SHORT
self._log.info(
'wall follower port angle: {:>5.2f}°; starboard angle: {:>5.2f}°'.
format(self._port_angle, self._stbd_angle))
self._servo = Servo(self._config, _servo_number, level)
self._tof = TimeOfFlight(_range, Level.WARN)
self._max_retries = 10
self._enabled = False
self._closed = False
self._log.info('ready.')
def test_ifs():
'''
Test the functionality of Integrated Front Sensor.
'''
_log = Logger("test-ifs", Level.INFO)
# read YAML configuration
_loader = ConfigLoader(Level.INFO)
filename = 'config.yaml'
_config = _loader.configure(filename)
_message_factory = MessageFactory(Level.INFO)
_message_bus = MessageBus(Level.INFO)
_log.info('creating clock...')
_clock = Clock(_config, _message_bus, _message_factory, Level.WARN)
_ifs = IntegratedFrontSensor(_config, _clock, Level.INFO)
# establish queue to receive messages
_queue = MockMessageQueue(Level.INFO)
_message_bus.add_handler(Message, _queue.add)
_ifs.enable()
_clock.enable()
while not _queue.all_triggered:
_queue.waiting_for_message()
time.sleep(0.5)
_ifs.disable()
assert _queue.count > 0
_log.info('test complete.' + Style.RESET_ALL)
def __init__(self, vs, imgOutput):
self.__vs = vs
self.__imgOutput = imgOutput
self.image = None
self.logger = Logger()
self.state = State()
self.tesseract = PyTessBaseAPI(psm=PSM.SINGLE_CHAR,
oem=OEM.LSTM_ONLY,
lang="digits")
self.filter = Filter()
self.signalThresholdY = 160
self.LAPPatternSesibility = 5
self.recordStamp = time.strftime(self.logger.timeFormat)
self.recordNum = 0
self.recordFolder = None
self.cntNum = 0
if (self.state.RecordImage):
root = 'record'
if not os.path.isdir(root):
os.mkdir(root)
self.recordFolder = os.path.join(root, self.recordStamp)
if not os.path.isdir(self.recordFolder):
os.mkdir(self.recordFolder)
def __init__(self, config, level):
self._log = Logger('uscanner', Level.INFO)
self._config = config
if self._config:
self._log.info('configuration provided.')
_config = self._config['ros'].get('ultrasonic_scanner')
self._min_angle = _config.get('min_angle')
self._max_angle = _config.get('max_angle')
self._degree_step = _config.get('degree_step')
self._use_raw_distance = _config.get('use_raw_distance')
self._read_delay_sec = _config.get('read_delay_sec')
self._log.info('read delay: {:>4.1f} sec'.format(
self._read_delay_sec))
_servo_number = _config.get('servo_number')
else:
self._log.warning('no configuration provided.')
self._min_angle = -60.0
self._max_angle = 60.0
self._degree_step = 3.0
self._use_raw_distance = False
self._read_delay_sec = 0.1
_servo_number = 2
self._log.info(
'scan from {:>5.2f} to {:>5.2f} with step of {:>4.1f}°'.format(
self._min_angle, self._max_angle, self._degree_step))
self._servo = Servo(self._config, _servo_number, level)
self._ub = self._servo.get_ultraborg()
# self._tof = TimeOfFlight(_range, Level.WARN)
self._error_range = 0.067
self._enabled = False
self._closed = False
self._log.info('ready.')
def __init__(self, motors, level):
self._log = Logger("roam", level)
self._port_pid = motors._port_pid
self._stbd_pid = motors._stbd_pid
self._roam_port_complete = False
self._roam_stbd_complete = False
self._log.info('ready.')
def main(argv):
logger = Logger()
try:
opts, args = getopt.getopt(argv,"hi:c:t:",["itask=","oconfig=","trace="])
except getopt.GetoptError:
print ('main.py -t <task_name>')
sys.exit(2)
taskTobeExecute = None
config = None
for opt, arg in opts:
if opt == '-h':
print ('main.py -t <task_name>')
sys.exit()
elif opt in ("-t", "--itask"):
taskTobeExecute = arg
#logger.getLogger(__name__).debug('This is a debug message')
elif opt in ("-c", "--cconfig"):
config = arg
taskHandler = TaskHandler(taskTobeExecute,config)
taskHandler.execute()
def __init__(self, level):
super().__init__()
self._counter = itertools.count()
self._log = Logger("queue", Level.INFO)
self._start_time = dt.now()
self._last_time = self._start_time
self._log.info('ready.')
def __init__(self, config, filename, level):
self._log = Logger("filewriter", level)
self._enabled = False
self._active = False
self._thread = None
# configuration ..............................................
cfg = config['ros'].get('filewriter')
_extension = cfg.get('extension')
_directory_name = cfg.get('directory_name')
_default_filename_prefix = cfg.get('default_filename_prefix')
self._gnuplot_template_file = cfg.get(
'gnuplot_template_file') # template for gnuplot settings
self._gnuplot_output_file = cfg.get(
'gnuplot_output_file') # output file for gnuplot settings
if not os.path.exists(_directory_name):
os.makedirs(_directory_name)
if filename is not None:
if filename.endswith(_extension):
self._filename = _directory_name + '/' + filename
else:
self._filename = _directory_name + '/' + filename + _extension
else:
# create os-friendly filename including current timestamp
self._filename = _directory_name + '/' + _default_filename_prefix \
+ datetime.utcfromtimestamp(datetime.utcnow().timestamp()).isoformat().replace(':','_').replace('-','_').replace('.','_') + _extension
self._log.info('ready.')
def __init__(self, task_name):
self.state = State.NONE
self.task_name = task_name
logger_name = "fsm:" + task_name
self._log = Logger(logger_name, level)
FiniteStateMachine.__transition__(self, State.INITIAL)
self._log.debug('fsm initialised.')
def test_analog():
_log = Logger("analog test", Level.INFO)
try:
_log.info('creating analog input...')
_analog = AnalogInput(Level.INFO)
_counter = itertools.count()
_log.info(Fore.RED + 'Press Ctrl+C to exit.')
while True:
_count = next(_counter)
_voltages = _analog.read()
_log.info(Fore.GREEN + Style.BRIGHT + '[{:03d}] channel 0: {:5.2f}V; channel 1: {:5.2f}V; channel 2: {:5.2f}V.'.format(\
_count, _voltages[0], _voltages[1], _voltages[2]))
time.sleep(1.0)
except KeyboardInterrupt:
print(Fore.RED + 'Ctrl-C caught: complete.')
except Exception as e:
print(Fore.RED +
'error closing: {}\n{}'.format(e, traceback.format_exc()))
_log.info('complete.')
def main():
try:
_log = Logger('test', Level.INFO)
print(Fore.BLACK + Style.BRIGHT + RULER + Style.RESET_ALL)
_base = 'abcdefghijklmnopqrtsuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789012345678901234567890'
_max_width = 80
_margin = 27 # right-most colon is column 27
_available_width = _max_width - _margin
# for i in range(1, _available_width):
for i in range(1, _available_width + 2):
_title = _base[:i]
_message1 = _base[:i]
_message2 = '[{:d}/{:d}]'.format(i, 10)
_log.header(_title, _message1, _message2)
_log.header(' ', None, None)
_log.header('com.google.code.gson:gson', None, None)
_log.header('commons-io:fileutils', 'Here\'s a message we want to display.', None)
_log.header('org.apache.commons:commons-lang3', 'Here\'s another message we want to display.', '[3/10]')
print(Fore.BLACK + Style.BRIGHT + RULER + Style.RESET_ALL)
except Exception as e:
_log.error('error in splenk processor: {}'.format(e))
traceback.print_exc(file=sys.stdout)
def test_message():
_log = Logger('message-test', Level.INFO)
try:
_log.info('start message test...')
_message_bus = MessageBus(Level.INFO)
_message_factory = MessageFactory(_message_bus, Level.INFO)
_subscriber1 = Subscriber('behaviour', Fore.YELLOW, _message_bus,
Level.INFO)
_message_bus.register_subscriber(_subscriber1)
_subscriber2 = Subscriber('infrared', Fore.MAGENTA, _message_bus,
Level.INFO)
_message_bus.register_subscriber(_subscriber2)
_subscriber3 = Subscriber('bumper', Fore.GREEN, _message_bus,
Level.INFO)
_message_bus.register_subscriber(_subscriber3)
_message_bus.print_publishers()
_message_bus.print_subscribers()
# ................................
_message = _message_factory.get_message(Event.BRAKE, True)
_log.info('created message {}; event: {}'.format(
_message.name, _message.event.name))
_message.acknowledge(_subscriber1)
_subscriber1.print_message_info('sub1 info for message:', _message,
None)
except Exception as e:
_log.error('error: {}'.format(e))
finally:
_log.info('complete.')
def __init__(self, config, tb, level):
super().__init__()
self._log = Logger('motors', level)
self._log.info('initialising motors...')
if tb is None:
tb = self._configure_thunderborg_motors(level)
if tb is None:
raise Exception('unable to configure thunderborg.')
self._tb = tb
self._set_max_power_ratio()
self._pi = pigpio.pi()
try:
from lib.motor_v2 import Motor
self._log.info('imported Motor.')
except Exception:
traceback.print_exc(file=sys.stdout)
self._log.error('failed to import Motor, exiting...')
sys.exit(1)
self._port_motor = Motor(config, self._tb, self._pi, Orientation.PORT,
level)
self._port_motor.set_max_power_ratio(self._max_power_ratio)
self._stbd_motor = Motor(config, self._tb, self._pi, Orientation.STBD,
level)
self._stbd_motor.set_max_power_ratio(self._max_power_ratio)
self._enabled = True # default enabled
# a dictionary of motor # to last set value
self._msgIndex = 0
self._last_set_power = {0: 0, 1: 0}
self._log.info('motors ready.')
def __init__(self, config, queue, level):
self._log = Logger("bno055", level)
if config is None:
raise ValueError("no configuration provided.")
self._config = config
self._queue = queue
_config = self._config['ros'].get('bno055')
self._quaternion_accept = _config.get(
'quaternion_accept') # permit Quaternion once calibrated
self._loop_delay_sec = _config.get('loop_delay_sec')
_i2c_device = _config.get('i2c_device')
# use `ls /dev/i2c*` to find out what i2c devices are connected
self._bno055 = adafruit_bno055.BNO055_I2C(
I2C(_i2c_device)) # Device is /dev/i2c-1
self._thread = None
self._enabled = False
self._closed = False
self._heading = None
self._pitch = None
self._roll = None
self._is_calibrated = False
self._log.info('ready.')
def main():
level = Level.INFO
log = Logger('main', level)
log.info('scanning for I2C devices...')
scanner = I2CScanner(Level.INFO)
_addresses = scanner.get_int_addresses()
log.info('available I2C device(s):')
if len(_addresses) == 0:
log.warning('no devices found.')
return
else:
for n in range(len(_addresses)):
address = _addresses[n]
log.info('device: {0} ({1})'.format(address, hex(address)))
for i in range(len(_addresses)):
print(Fore.CYAN + '-- address: {}'.format(_addresses[i]) + Style.RESET_ALL)
print('')
if THUNDERBORG_ADDRESS in _addresses:
print(Fore.CYAN + '-- thunderborg found at address {}: using motors/motor'.format(THUNDERBORG_ADDRESS) + Style.RESET_ALL)
# from motors import Motors
# from motor import Motor
else:
print(Fore.MAGENTA + '-- thunderborg not found at address {}: using motors/motor'.format(THUNDERBORG_ADDRESS) + Style.RESET_ALL)
def main(argv):
_temp = None
_log = Logger('temp-test', Level.INFO)
try:
# read YAML configuration
_loader = ConfigLoader(Level.INFO)
filename = 'config.yaml'
_config = _loader.configure(filename)
_queue = MessageQueue(Level.DEBUG)
_temp = Temperature(_config, _queue, Level.INFO)
_temp.enable()
while True:
# _value = _temp.get_cpu_temperature()
# _is_hot = _temp.is_hot()
time.sleep(1.0)
except KeyboardInterrupt:
_log.info(Fore.YELLOW + 'exited via Ctrl-C' + Style.RESET_ALL)
if _temp:
_temp.close()
sys.exit(0)
except Exception:
_log.error(Fore.RED + Style.BRIGHT +
'error getting RPI temperature: {}'.format(
traceback.format_exc()) + Style.RESET_ALL)
if _temp:
_temp.close()
sys.exit(1)
