def module_test():
import logging
from i2cdevice import I2CDevice
logger = Logger()
logger.debug("Start Module Test")
i2c_device = I2CDevice(I2CDevice.DEV_I2C_1, logger=logger)
imu = ImuDevice(name="imu device",
device=i2c_device,
timeout=5,
logger=logger)
logger.debug("End Module Test")
def module_test():
from i2cdevice import I2CDevice
import time
logger = Logger()
logger.debug("Performing module test")
try:
i2c_device = I2CDevice(device=I2CDevice.DEV_I2C_1, logger=logger)
except I2CDeviceError as err:
logger.fatal("Unable to instantiate Psoc hardware", err)
psoc_device = PsocI2CDevice(name='psoc device', device=i2c_device)
for i in range(10):
msg = psoc_device.recv()
logger.debug(msg)
time.sleep(1)
def module_test():
import time
from ..devices.i2cdevice import I2CDevice
from ..devices.psocdevice import PsocI2CDevice
def callback(msg):
logger.debug("{} - {}".format(time.time(), msg))
logger = Logger()
logger.debug("{} {}".format(__name__, " Module Test"))
i2c_device = I2CDevice(device=I2CDevice.DEV_I2C_1)
device = PsocI2CDevice(name='psoc device', device=i2c_device)
driver = PsocDriver(name='psochw i2c driver', device=device)
driver.start(callback)
time.sleep(5)
driver.stop()
def module_test():
from psochwfactory import PsocHwFactory
def callback(msg):
logger.debug("delivered callback msg: {}".format(msg))
logger = Logger()
logger.debug("{} {}".format(__name__, "Module Test"))
#psochw = PsocHwFactory.create_can(callback)
#time.sleep(1)
#psochw.shutdown()
psochw = PsocHwFactory.create_i2c(callback, logger=logger)
logger.debug("Starting psochw ...")
psochw.start()
logger.debug("Started")
time.sleep(0.01)
logger.debug("Shutting down psochw ...")
psochw.shutdown()
logger.debug("Shutdown")
def load_calibration():
global CALIBRATION_DATA
logger = Logger()
try:
# To load the calibration data it is necessary to get the absolutate path. The calibration data is stored in the
# same directory as this module. The __file__ attribute contains the needed path information.
abs_path = os.path.dirname(os.path.abspath(__file__))
f = open(os.path.join(abs_path, 'bno055.cal'), 'r')
except IOError as err:
logger.fatal(
"Unable to load calibration data from bno055.cal - {}".format(err))
else:
with f:
l = f.readline()
s = l[1:-1]
try:
CALIBRATION_DATA = [int(i) for i in s.split(', ')]
logger.debug(
"Calibration Data Loaded: {}".format(CALIBRATION_DATA))
except ValueError as err:
logger.fatal("Invalid calibration data: {} - {}".format(
s, err))
class AthenaOpt(object):
"""
The primary class for AthenaOpt that controls program logic.
"""
def __init__(self):
"""
AthenaOpt constructor
@return: None
"""
self._configuration = None
self._logger = None
self._directory = None
def run(self, configuration):
"""
Run the optimization and place output files in the directory specified by the configuration.
@param configuration: The optimization configuration object
@type configuration: Configuration
@return: The run history
@rtype: History
"""
# Parse the configuration
self._configuration = configuration
self._directory = self._configuration.get_directory()
if not path.exists(self._directory):
makedirs(self._directory)
self._logger = Logger(self._directory + '/' + configuration.get_log_file(),
configuration.get_log_level(), configuration.get_console_log_level())
self._logger.info('Athena optimization run started')
# Load the model
if self._configuration.get_model() == 'ZDT1':
model = ZDT1()
self._logger.info('Model ZDT1 selected')
elif self._configuration.get_model() == 'ZDT2':
model = ZDT2()
self._logger.info('Model ZDT2 selected')
elif self._configuration.get_model() == 'ZDT3':
model = ZDT3()
self._logger.info('Model ZDT3 selected')
elif self._configuration.get_model() == 'ZDT4':
model = ZDT4()
self._logger.info('Model ZDT4 selected')
elif self._configuration.get_model() == 'ZDT6':
model = ZDT6()
self._logger.info('Model ZDT6 selected')
elif self._configuration.get_model() == 'DTLZ1':
model = DTLZ1()
self._logger.info('Model DTLZ1 selected')
elif self._configuration.get_model() == 'DTLZ2':
model = DTLZ2()
self._logger.info('Model DTLZ2 selected')
elif self._configuration.get_model() == 'DTLZ3':
model = DTLZ3()
self._logger.info('Model DTLZ3 selected')
elif self._configuration.get_model() == 'TNK':
model = TNK()
self._logger.info('Model TNK selected')
elif self._configuration.get_model() == 'PACKING':
model = PACKING()
self._logger.info('Model PACKING selected')
elif self._configuration.get_model() == 'POLONI':
model = POLONI()
self._logger.info('Model POLONI selected')
else:
self._logger.error('Unable to determine model ' + self._configuration.get_model())
raise AthenaException('Unable to determine model ' + self._configuration.get_model())
# Load the algorithm
if self._configuration.get_algorithm() == 'SERIAL':
algorithm = Serial()
self._logger.info('Algorithm SERIAL selected')
elif self._configuration.get_algorithm() == 'ISLANDS':
algorithm = Islands()
self._logger.info('Algorithm ISLANDS selected')
elif self._configuration.get_algorithm() == 'SPHERES':
algorithm = Spheres()
self._logger.info('Algorithm SPHERES selected')
else:
self._logger.error('Unable to determine algorithm ' + self._configuration.get_algorithm())
raise AthenaException('Unable to determine algorithm ' + self._configuration.get_algorithm())
# Run the optimization
self._logger.debug('Setting the logger to the algorithm')
algorithm.set_logger(self._logger)
self._logger.debug('Setting the model to the algorithm')
algorithm.set_model(model)
self._logger.info('Starting the algorithm')
algorithm.parse_configuration(configuration)
history, convergence, solution = algorithm.run()
json_convergence = json.dumps(convergence, default=encode_convergence_metrics, sort_keys=True, indent=2)
if configuration.get_write_history():
json_history = history.to_json()
with open(self._directory + '/generations.out', 'w+') as data_file:
data_file.write(json_history)
if configuration.get_write_solution():
json_solution = json.dumps(solution, default=encode_individual, sort_keys=True, indent=2)
with open(self._directory + '/solution.out', 'w+') as soln_file:
soln_file.write(json_solution)
with open(self._directory + '/convergence.out', 'w+') as convergence_file:
convergence_file.write(json_convergence)
with open(self._directory + '/configuration.config', 'w+') as config_file:
config_file.write(configuration.to_json())
self._logger.info('Optimization finished')
return history
def create_i2c(cls, driver_cb, logger=None):
if not logger:
logger = Logger()
logger.debug("({}) - Creating I2CDevice ...".format(__name__))
try:
i2c_device = I2CDevice(device=I2CDevice.DEV_I2C_1, logger=logger)
except I2CDeviceError as err:
raise PsocHwFactoryError("Unable to instantiate Psoc hardware",
err)
logger.debug("({}) - Complete".format(__name__))
logger.debug("({}) - Creating PsocI2CDevice ...".format(__name__))
try:
device = PsocI2CDevice(name='psoc device',
device=i2c_device,
logger=logger)
except PsocDeviceError as err:
raise PsocHwFactoryError("Unable to instantiate Psoc hardware",
err)
logger.debug("({}) - Complete".format(__name__))
logger.debug("({}) - Creating PsocDriver ...".format(__name__))
try:
driver = PsocDriver(name='psochw i2c driver',
device=device,
logger=logger)
except PsocDriverError as err:
raise PsocHwFactoryError("Unable to instantiate Psoc hardware",
err)
logger.debug("({}) - Complete".format(__name__))
logger.debug("({}) - Creating PsocHw ...".format(__name__))
try:
return PsocHw(driver_if=driver, driver_cb=driver_cb, logger=logger)
except PsocHwError as err:
raise PsocHwFactoryError("Unable to instantiate Psoc hardware",
err)
logger.debug("({}) - Complete".format(__name__))
