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__))