def test_minimum_maximum():
"""Test the minimum and maximum methods"""
time0 = datetime.datetime.now()
units = "metres"
distance0 = Measure(5, units, time0)
distance1 = Measure(6, units, time0)
distance2 = Measure(4, units, time0)
name = "distance"
capacity = 5
accumulator = Accumulator(name, capacity)
assert accumulator.minimum() == None
assert accumulator.maximum() == None
accumulator.push(distance0)
accumulator.push(distance1)
accumulator.push(distance2)
assert accumulator.minimum().value == distance2.value
assert accumulator.maximum().value == distance1.value
def test_median():
time = datetime.datetime.now()
units = "metres"
distance0 = Measure(5, units, time)
distance1 = Measure(6, units, time)
distance2 = Measure(12, units, time)
distance3 = Measure(20, units, time)
name = "distance"
capacity = 5
accumulator = Accumulator(name, capacity)
assert accumulator.median() == None
accumulator.push(distance0)
accumulator.push(distance1)
accumulator.push(distance2)
accumulator.push(distance3)
# use the upper middle measure if there are an even number
assert accumulator.median().value == 12
def test_newest():
time0 = datetime.datetime.now()
units = "metres"
distance0 = Measure(5, units, time0)
distance1 = Measure(6, units, time0)
name = "distance"
capacity = 5
accumulator = Accumulator(name, capacity)
assert accumulator.newest() == None
accumulator.push(distance0)
accumulator.push(distance1)
assert accumulator.newest().value == distance1.value
def test_empty_clear():
"""Test the empty property and clear method"""
name = "test"
capacity = 2
accumulator = Accumulator(name, capacity)
assert accumulator.empty
value = 1
units = "metres"
time = datetime.datetime.now()
measure = Measure(value, units, time)
accumulator.push(measure)
assert not accumulator.empty
accumulator.clear()
assert accumulator.empty
def __init__(self, config: IConfiguration, deviceCollection: IDeviceCollection):
assert isinstance(config, IConfiguration)
self._config = config
assert isinstance(deviceCollection, IDeviceCollection)
self._deviceCollection = deviceCollection
self._deviceCollection.init_devices()
self.GPS_INTERVAL = self._config.gps_interval
self.THERMO_INTERVAL = self._config.thermo_interval
self.ACCEL_INTERVAL = self._config.accel_interval
self.VOLT_INTERVAL = self._config.volt_interval
self.BARO_INTERVAL = self._config.baro_interval
self.RPM_INTERVAL = self._config.rpm_interval
self.SPEED_INTERVAL = self._config.speed_interval
self.PRINT_INTERVAL = self._config.manager_print_interval
self.MOVING_AVERAGE_ITEMS = self._config.manager_moving_average_items
self._longtitudes = Accumulator("Longitude", self.MOVING_AVERAGE_ITEMS)
self._latitudes = Accumulator("Latitude", self.MOVING_AVERAGE_ITEMS)
self._altitudes = Accumulator("Altitude", self.MOVING_AVERAGE_ITEMS)
self._temperatures = Accumulator("Temperature", self.MOVING_AVERAGE_ITEMS)
self._accelerations = Accumulator("Acceleration", self.MOVING_AVERAGE_ITEMS)
self._voltages = Accumulator("Voltage", self.MOVING_AVERAGE_ITEMS)
self._pressures = Accumulator("Pressure", self.MOVING_AVERAGE_ITEMS)
self._rpms = Accumulator("RPM", self.MOVING_AVERAGE_ITEMS)
self._speeds = Accumulator("Speed", self.MOVING_AVERAGE_ITEMS)
self.NAME_WIDTH = 14
self.VALUE_WIDTH = 7
self.UNITS_WIDTH = 8
self.DEFAULT_ROUNDING_DIGITS = 2
self.LATITUDE_ROUNDING_DIGITS = 4
self._workerList = list()
self.create_workers()
self.start_workers()
class Manager():
"""Automates reading from devices"""
def __init__(self, config: IConfiguration, deviceCollection: IDeviceCollection):
assert isinstance(config, IConfiguration)
self._config = config
assert isinstance(deviceCollection, IDeviceCollection)
self._deviceCollection = deviceCollection
self._deviceCollection.init_devices()
self.GPS_INTERVAL = self._config.gps_interval
self.THERMO_INTERVAL = self._config.thermo_interval
self.ACCEL_INTERVAL = self._config.accel_interval
self.VOLT_INTERVAL = self._config.volt_interval
self.BARO_INTERVAL = self._config.baro_interval
self.RPM_INTERVAL = self._config.rpm_interval
self.SPEED_INTERVAL = self._config.speed_interval
self.PRINT_INTERVAL = self._config.manager_print_interval
self.MOVING_AVERAGE_ITEMS = self._config.manager_moving_average_items
self._longtitudes = Accumulator("Longitude", self.MOVING_AVERAGE_ITEMS)
self._latitudes = Accumulator("Latitude", self.MOVING_AVERAGE_ITEMS)
self._altitudes = Accumulator("Altitude", self.MOVING_AVERAGE_ITEMS)
self._temperatures = Accumulator("Temperature", self.MOVING_AVERAGE_ITEMS)
self._accelerations = Accumulator("Acceleration", self.MOVING_AVERAGE_ITEMS)
self._voltages = Accumulator("Voltage", self.MOVING_AVERAGE_ITEMS)
self._pressures = Accumulator("Pressure", self.MOVING_AVERAGE_ITEMS)
self._rpms = Accumulator("RPM", self.MOVING_AVERAGE_ITEMS)
self._speeds = Accumulator("Speed", self.MOVING_AVERAGE_ITEMS)
self.NAME_WIDTH = 14
self.VALUE_WIDTH = 7
self.UNITS_WIDTH = 8
self.DEFAULT_ROUNDING_DIGITS = 2
self.LATITUDE_ROUNDING_DIGITS = 4
self._workerList = list()
self.create_workers()
self.start_workers()
def print_all_accumulator_means(self):
while(True):
os.system('clear')
print("MEASURE | VALUE | UNITS | TIME")
self.print_accumulator_mean(self._longtitudes)
self.print_accumulator_mean(self._latitudes, self.LATITUDE_ROUNDING_DIGITS)
self.print_accumulator_mean(self._altitudes)
self.print_accumulator_mean(self._temperatures)
self.print_accumulator_mean(self._accelerations)
self.print_accumulator_mean(self._voltages)
self.print_accumulator_mean(self._pressures)
self.print_accumulator_mean(self._rpms)
self.print_accumulator_mean(self._speeds)
time.sleep(self.PRINT_INTERVAL)
def print_accumulator_mean(self, accumulator, roundDigits = None):
if (roundDigits == None):
roundDigits = self.DEFAULT_ROUNDING_DIGITS
mean = accumulator.mean()
if (mean != None):
nameString = accumulator.name.ljust(self.NAME_WIDTH)
valueString = str(round(mean.value, roundDigits)).rjust(self.VALUE_WIDTH)
unitsString = mean.units.rjust(self.UNITS_WIDTH)
timeString = " " + str(mean.time.time())
string = nameString + valueString + unitsString + timeString
print(string)
def create_workers(self):
self.create_gps_worker_thread()
self.create_worker_thread(self._temperatures, DeviceConstants.DEVICE_THERMO, self.THERMO_INTERVAL)
self.create_worker_thread(self._accelerations, DeviceConstants.DEVICE_ACCEL, self.ACCEL_INTERVAL)
self.create_worker_thread(self._voltages, DeviceConstants.DEVICE_VOLT, self.VOLT_INTERVAL)
self.create_worker_thread(self._pressures, DeviceConstants.DEVICE_BARO, self.BARO_INTERVAL)
self.create_worker_thread(self._rpms, MeasureConstants.RPM, self.RPM_INTERVAL)
self.create_worker_thread(self._speeds, MeasureConstants.SPEED, self.SPEED_INTERVAL)
def create_worker_thread(self, accumulator, measureString, interval):
thread = threading.Thread(name = measureString, target=self.measure_worker,
args=(accumulator, measureString, interval), daemon=True)
self._workerList.append(thread)
def measure_worker(self, accumulator, measureString, interval):
while(True):
self.read_measure(accumulator, measureString)
time.sleep(interval)
def read_measure(self, accumulator, measureString):
accumulator.push(self._deviceCollection.read_current_data(measureString))
def create_gps_worker_thread(self):
# gps is a special case because location consists of three measures
gps_thread = threading.Thread(name = DeviceConstants.DEVICE_GPS, target=self.location_worker, daemon=True)
self._workerList.append(gps_thread)
def location_worker(self):
while(True):
self.read_location()
time.sleep(self.GPS_INTERVAL)
def read_location(self):
location = self._deviceCollection.read_current_data(DeviceConstants.DEVICE_GPS)
self._latitudes.push(location.latitude)
self._longtitudes.push(location.longitude)
self._altitudes.push(location.altitude)
def start_workers(self):
for each in self._workerList:
each.start()
def test_name():
name = "test"
capacity = 2
accumulator = Accumulator(name, capacity)
assert accumulator.name == name
def test_mean():
"""Test the mean() method and test that the correct capacity is used"""
time = datetime.datetime.now()
units = "metres"
distance0 = Measure(5, units, time)
distance1 = Measure(6, units, time)
distance2 = Measure(12, units, time)
distance3 = Measure(20, units, time)
average_value = (5 + 6 + 12 + 20) / 4
name = "distance"
capacity = 5
accumulator = Accumulator(name, capacity)
assert accumulator.mean() == None
accumulator.push(distance0)
accumulator.push(distance1)
accumulator.push(distance2)
accumulator.push(distance3)
assert accumulator.mean().value == average_value
# push more entries to check that the previous entries are dropped
# once we go over the accumulator's capacity
distance4 = Measure(1, units, time)
distance5 = Measure(1, units, time)
distance6 = Measure(1, units, time)
distance7 = Measure(1, units, time)
distance8 = Measure(1, units, time)
accumulator.push(distance4)
accumulator.push(distance5)
accumulator.push(distance6)
accumulator.push(distance7)
accumulator.push(distance8)
assert accumulator.mean().value == 1