def __instantiate_devices(
config: dict,
application: ApplicationManager) -> List[Tuple[DeviceModule, dict]]:
devices_with_config = []
devices = config.get('devices', {})
counter = 0x0200
for name, device_def in devices.items():
if not (isinstance(device_def, dict) or 'module_name' in device_def):
raise ConfigValidationError(
'devices/' + name,
'Should be dictionary containing mandatory module_name key')
module_registry = application.get_module_registry()
instance = module_registry.create_module_instance(
application,
typeid=module_registry.find_module_by_name(
device_def.get('module_name')).typeid(),
instance_name=name,
instance_id=counter + 1)
try:
# Parse and set parameters
for param_def in instance.PARAMS:
if param_def.name in device_def:
val = device_def[param_def.name]
if param_def.parser is not None:
val = param_def.parser.parse(
val, application,
'devices/{}/{}'.format(name, param_def.name))
param_def.validate(val)
setattr(instance, param_def.name, val)
elif param_def.is_required:
raise ConfigValidationError(
'devices/{}/{}'.format(name, param_def.name),
'Parameter {} is required'.format(param_def.name))
# Run validation of the overall device
instance.validate()
#instance.on_initialized()
except Exception as e:
raise ConfigValidationError(
"devices/" + name, "Invalid device configuration: " + str(e),
e)
application.register_device(instance)
devices_with_config.append((instance, device_def))
__logger.debug("Initialized device {}({}). Type: {}({})".format(
int_to_hex4str(instance.id), instance.name,
int_to_hex4str(instance.typeid()), instance.type_name()))
counter += 1
return devices_with_config
def __repr__(self, *args, **kwargs):
return 'ActionDef({}, {})'.format(int_to_hex4str(self.id), self.name)
def __str__(self, *args, **kwargs):
return '{}({})'.format(self.type_name(), int_to_hex4str(self.typeid()))
def handle(self, args):
modules = self.get_application_manager().get_module_registry(
).modules.values()
for module in modules:
CLI.print_data('* {} (id: {})'.format(
module.type_name(), utils.int_to_hex4str(module.typeid())))
def handle(self, args):
drivers = self.get_application_manager().drivers.values()
for driver in drivers:
CLI.print_data('* {} (id: {})'.format(
driver.type_name(), utils.int_to_hex4str(driver.typeid())))