def update_param(self, execution_name, filter_name, param_name, value):
request = server_pb2.UpdateParamRequest()
request.execution_name = execution_name
request.filter_name = filter_name;
request.param.name = param_name
if type(value) is int:
request.param.value_int = value
if type(value) is bool:
request.param.value_bool = value
if type(value) is float:
request.param.value_float = value
if type(value) is str or type(value) is unicode:
request.param.value_str = value
# Make an synchronous call
returnValue = None
try:
response = self.service.update_param(request, timeout=10000)
if response:
returnValue = not response.status
if not returnValue:
if response.HasField("message"):
logger.error("update_param : %s", response.message)
else:
logger.error("update_param.")
else:
returnValue = False
except Exception as e:
log.printerror_stacktrace(logger, e)
return returnValue
def reload_filter(self, filtre=None):
"""
Reload Filter.
Param : filtre - if None, reload all filter, else reload filter name
"""
request = server_pb2.ReloadFilterRequest()
if type(filtre) is list:
for item in filtre:
request.filterName.append(item)
elif type(filtre) is str or type(filtre) is unicode:
request.filterName.append(filtre)
elif filtre is not None:
raise Exception("filtre is wrong type : %s" % type(filtre))
# Make an synchronous call
returnValue = None
try:
response = self.service.reload_filter(request, timeout=10000)
if response:
returnValue = not response.status
if not returnValue:
if response.HasField("message"):
logger.error("reload_filter : %s", response.message)
else:
logger.error("reload_filter.")
else:
returnValue = False
except Exception as e:
log.printerror_stacktrace(logger, e)
return returnValue
def _create_params(self):
self.dct_params = {}
if not self.camera:
return
lst_ignore_prop = ["Trigger"]
dct_prop = self.camera.get_dict_available_features()
for name, value in dct_prop.items():
if name in lst_ignore_prop:
continue
try:
if name == "White Balance":
param = Param("%s%s" % (name, self.key_auto_param), False)
param.add_notify_reset(self.update_property_param)
self.dct_params[param.get_name()] = param
param = Param("%s-red" % name, value["RV_value"], min_v=value["min"], max_v=value["max"])
param.add_notify_reset(self.update_property_param)
self.dct_params[param.get_name()] = param
param = Param("%s-blue" % name, value["BU_value"], min_v=value["min"], max_v=value["max"])
param.add_notify_reset(self.update_property_param)
self.dct_params[param.get_name()] = param
continue
elif name == "Shutter" or name == "Gain":
param = Param("%s%s" % (name, self.key_auto_param), False)
param.add_notify_reset(self.update_property_param)
self.dct_params[param.get_name()] = param
param = Param(name, value["value"], min_v=value["min"], max_v=value["max"])
param.add_notify_reset(self.update_property_param)
self.dct_params[param.get_name()] = param
except Exception as e:
log.printerror_stacktrace(logger, "%s - name: %s, value: %s" % (e, name, value))
def run(self):
max_error = 100
nb_error = 0
self.socket.connect("tcp://%s:%s" % (self.addr, self.port))
# TODO bug, it's not normal to subscribe for all topic
self.socket.setsockopt(zmq.SUBSCRIBE, '')
# Don't exit at first error receiving
while nb_error < max_error and not self.is_stopped:
try:
while not self.is_stopped:
# try:
data = self.socket.recv_pyobj()
if data:
self.observer(data)
# except zmq.error.ZMQError:
# ignore it, it's the timeout
# TODO can we do something with ZMQError?
# pass
except zmq.error.ZMQError as e:
# errno 11 is Resource temporarily unavailable
if e.errno == 11:
continue
# Context was terminated
if e.errno == 156384765:
self.is_stopped = True
continue
log.printerror_stacktrace(logger, e)
except BaseException as e:
log.printerror_stacktrace(logger, e)
nb_error += 1
self.socket.close()
def remove_image_observer(self, controller, request, done):
logger.info("remove_image_observer request %s", str(request).replace("\n", " "))
# Create a reply
response = server_pb2.StatusResponse()
try:
observer = self.dct_observer.get(request.execution_name, None)
if observer and self.manager.remove_image_observer(observer.observer, request.execution_name, request.filter_name):
response.status = 0
else:
response.status = 1
response.message = "This remove_image_observer can't remove observer."
except Exception as e:
log.printerror_stacktrace(logger, e)
response.status = -1
# We're done, call the run method of the done callback
done.run(response)
# close the socket
observer = self.dct_observer.get(request.execution_name, None)
if observer:
observer.close()
del self.dct_observer[request.execution_name]
def stop_filterchain_execution(self, execution_name):
"""
Stop a filterchain on the server.
Param : str - The unique execution name
"""
request = server_pb2.StopFilterchainExecutionRequest()
request.execution_name = execution_name
# Make an synchronous call
returnValue = None
try:
response = self.service.stop_filterchain_execution(request, timeout=10000)
if response:
returnValue = not response.status
if not returnValue:
if response.HasField("message"):
logger.error("stop_filterchain_execution : %s", response.message)
else:
logger.error("stop_filterchain_execution.")
else:
returnValue = False
except Exception as e:
log.printerror_stacktrace(logger, e)
return returnValue
def _create_module(cpptimestamps, module, modname, mod):
try:
logger.info("Begin compile %s.", modname)
if cpptimestamps.has_key(modname):
# Reloaded modules are saved in the reload folder for easy cleanup
mod.compile(RELOAD_DIR)
else:
mod.compile(BUILD_DIR)
cppmodule = __import__(modname)
params = {}
dct_fct = {'__init__' : create_init(getattr(cppmodule, 'init_' + modname), params),
'execute' : create_execute(getattr(cppmodule, 'exec_' + modname)),
'py_init_param' : py_init_param,
'py_init_global_param' : py_init_global_param,
'set_original_image' : create_set_original_image(getattr(cppmodule, 'set_original_image_' + modname)),
'set_global_params_cpp' : create_set_global_params(getattr(cppmodule, 'set_global_params_' + modname)),
'__doc__' : getattr(cppmodule, 'help_' + modname)()
}
if has_configure:
dct_fct['configure'] = create_configure(getattr(cppmodule, 'config_' + modname))
if has_destroy:
dct_fct['destroy'] = create_destroy(getattr(cppmodule, 'destroy_' + modname))
clazz = type(modname,
(Filter,),
dct_fct)
clazz.__module_init__ = module
setattr(module, modname, clazz)
del clazz
except Exception as e:
log.printerror_stacktrace(logger, e)
def delete_filterchain(self, filterchain_name):
"""
deleter a filterchain
Param : str - filterchain name
"""
request = server_pb2.DeleteFilterChainRequest()
request.filterchain_name = filterchain_name
# Make an synchronous call
returnValue = None
try:
response = self.service.delete_filterchain(request, timeout=10000)
if response:
returnValue = not response.status
if not returnValue:
if response.HasField("message"):
logger.error("delete_filterchain : %s", response.message)
else:
logger.error("delete_filterchain.")
else:
returnValue = False
except Exception as e:
log.printerror_stacktrace(logger, e)
return returnValue
def remove_output_observer(self, execution_name):
"""
remove the output information of execution to tcp_server
supported only one observer. remove observer to tcp_server
"""
request = server_pb2.RemoveOutputObserverRequest()
request.execution_name = execution_name
# Make an synchronous call
returnValue = None
try:
response = self.service.remove_output_observer(request, timeout=10000)
if response:
returnValue = not response.status
if not returnValue:
if response.HasField("message"):
logger.error("remove_output_observer : %s", response.message)
else:
logger.error("remove_output_observer.")
else:
returnValue = False
except Exception as e:
log.printerror_stacktrace(logger, e)
return returnValue
def update_param(self, controller, request, done):
logger.info("update_param request %s", str(request).replace("\n", " "))
# Create a reply
response = server_pb2.StatusResponse()
try:
value = None
if request.param.HasField("value_int"):
value = request.param.value_int
if request.param.HasField("value_bool"):
value = request.param.value_bool
if request.param.HasField("value_float"):
value = request.param.value_float
if request.param.HasField("value_str"):
value = request.param.value_str
try:
response.status = not(self.manager.update_param(request.execution_name, request.filter_name, request.param.name, value))
except Exception as e:
response.status = 1
response.message = e
except Exception as e:
log.printerror_stacktrace(logger, e)
response.status = -1
# We're done, call the run method of the done callback
done.run(response)
def upload_filterchain(self, filterchain_name, s_file_contain):
"""
upload a filterchain
Param : str - filterchain name
str - the filterchain file
"""
request = server_pb2.UploadFilterChainRequest()
request.filterchain_name = filterchain_name
request.s_file_contain = s_file_contain
# Make an synchronous call
returnValue = None
try:
response = self.service.upload_filterchain(request, timeout=10000)
if response:
returnValue = not response.status
if not returnValue:
if response.HasField("message"):
logger.error("upload_filterchain : %s", response.message)
else:
logger.error("upload_filterchain.")
else:
returnValue = False
except Exception as e:
log.printerror_stacktrace(logger, e)
return returnValue
def start_filterchain_execution(self, execution_name, media_name, filterchain_name, file_name=None, is_client_manager=False):
"""
Start a filterchain on the server.
Param : str - The unique execution name
str - The unique media name
str - The unique filterchain name
"""
request = server_pb2.StartFilterchainExecutionRequest()
request.execution_name = execution_name
request.media_name = media_name
request.filterchain_name = filterchain_name
if file_name:
request.file_name = file_name
request.is_client_manager = is_client_manager
# Make an synchronous call
returnValue = None
try:
response = self.service.start_filterchain_execution(request, timeout=10000)
if response:
returnValue = not response.status
if not returnValue:
if response.HasField("message"):
logger.error("start_filterchain_execution : %s", response.message)
else:
logger.error("start_filterchain_execution.")
else:
returnValue = False
except Exception as e:
log.printerror_stacktrace(logger, e)
return returnValue
def modify_filterchain(self, old_filterchain_name, new_filterchain_name, lst_str_filters, default_media):
"""
Edit or create a new filterchain
Param : str - old_filterchain name
str - new_filterchain name
list - the list in string of filters
"""
request = server_pb2.ModifyFilterChainRequest()
request.old_filterchain_name = old_filterchain_name
request.new_filterchain_name = new_filterchain_name
request.default_media = default_media
for filter_name in lst_str_filters:
request.lst_str_filters.add().name = filter_name
# Make an synchronous call
returnValue = None
try:
response = self.service.modify_filterchain(request, timeout=10000)
if response:
returnValue = not response.status
if not returnValue:
if response.HasField("message"):
logger.error("modify_filterchain : %s", response.message)
else:
logger.error("modify_filterchain.")
else:
returnValue = False
except Exception as e:
log.printerror_stacktrace(logger, e)
return returnValue
def __init__(self, controller, host="localhost", islocal=False):
super(WinMain, self).__init__()
self.host = host
self.controller = controller
self.dct_preview = {}
self.ui = get_ui(self)
self.uid_iter = 0
self.id = -1
# default maximize Qt
self.showMaximized()
# create dockWidgets
self.winFilter = WinFilter(self.controller)
self.winCamera = WinCamera(self.controller)
self.winFilterList = WinFilterList(self.controller)
self.winMedia = WinMedia(self.controller)
self.winExecution = WinExecution(self.controller)
self.winFilterChain = WinFilterChain(self.controller)
self.WinMainViewer = WinMainViewer()
# Add default widget
self.show_win_filter(first_time=True)
#self.show_win_camera(first_time=True)
self.show_win_filterlist(first_time=True)
self.show_win_filterchain(first_time=True)
self.show_win_media(first_time=True)
self.show_win_execution(first_time=True)
# Signal
self.winFilterList.onAddFilter.connect(self.winFilterChain.add_filter)
self.ui.btnMedia.clicked.connect(self.show_win_media)
self.ui.btnFilterChain.clicked.connect(self.show_win_filterchain)
self.ui.btnFilterList.clicked.connect(self.show_win_filterlist)
self.ui.btnExecution.clicked.connect(self.show_win_execution)
self.ui.btnCamera.clicked.connect(self.show_win_camera)
self.ui.btnParam.clicked.connect(self.show_win_filter)
self.winExecution.onPreviewClick.connect(self.addPreview)
self.winExecution.onExecutionChanged.connect(self.winFilterChain.select_filterchain)
self._addToolBar()
self.setCentralWidget(self.WinMainViewer.ui)
# register to notify server
if not islocal:
self.id = self.controller.add_notify_server()
self.start_pull = self.id is not None
try:
if self.start_pull:
thread.start_new_thread(self.poll_notify_server, ())
except Exception as e:
log.printerror_stacktrace(logger, e)
else:
self.start_pull = False
def save_params(self, controller, request, done):
logger.info("save_params request %s", str(request).replace("\n", " "))
# Create a reply
response = server_pb2.StatusResponse()
try:
response.status = not(self.manager.save_params(request.execution_name))
except Exception as e:
log.printerror_stacktrace(logger, e)
response.status = -1
# We're done, call the run method of the done callback
done.run(response)
def upload_filterchain(self, controller, request, done):
logger.info("upload_filterchain request %s", str(request).replace("\n", " "))
# Create a reply
response = server_pb2.StatusResponse()
try:
response.status = int(not self.manager.upload_filterchain(request.filterchain_name, request.s_file_contain))
except Exception as e:
log.printerror_stacktrace(logger, e)
response.status = -1
# We're done, call the run method of the done callback
done.run(response)
def get_execution_list(self, controller, request, done):
logger.info("get_execution_list request %s", str(request).replace("\n", " "))
# Create a reply
response = server_pb2.GetExecutionResponse()
try:
for execution in self.manager.get_execution_list():
response.execution.append(execution)
except Exception as e:
log.printerror_stacktrace(logger, e)
# We're done, call the run method of the done callback
done.run(response)
def get_real_fps_execution(self, controller, request, done):
# logger.info("get_real_fps_execution request %s", str(request).replace("\n", " "))
# Create a reply
response = server_pb2.GetRealFpsExecutionResponse()
try:
response.fps = self.manager.get_real_fps_execution(request.execution_name)
except Exception as e:
log.printerror_stacktrace(logger, e)
response.fps = -1
# We're done, call the run method of the done callback
done.run(response)
def open(self):
try:
shape = self.dct_resolution[self.dct_params.get("resolution").get()]
fps = self.dct_fps[self.dct_params.get("fps").get()]
self.video = pygame.camera.Camera(self.own_config.path, shape)
self.video.start()
self.thread_image = True
thread.start_new_thread(self.update_image, ())
except Exception as e:
log.printerror_stacktrace(logger, "Open camera %s: %s" % (self.get_name(), e))
return False
# call open when video is ready
return Media_streaming.open(self)
def get_execution_info(self, execution_name):
request = server_pb2.GetExecutionInfoRequest()
request.execution = execution_name
# Make an synchronous call
returnValue = None
try:
response = self.service.get_execution_info(request, timeout=10000)
if response:
return response
except Exception as e:
log.printerror_stacktrace(logger, e)
return None
def get_execution_list(self):
request = server_pb2.GetExecutionRequest()
# Make an synchronous call
returnValue = None
try:
response = self.service.get_execution_list(request, timeout=10000)
if response:
return response.execution
except Exception as e:
log.printerror_stacktrace(logger, e)
return []
def get_execution_info(self, controller, request, done):
logger.info("get_execution_info request %s", str(request).replace("\n", " "))
# Create a reply
response = server_pb2.GetExecutionInfoResponse()
try:
o_exec = self.manager.get_execution_info(request.execution)
response.filterchain = o_exec.filterchain
response.media = o_exec.media
except Exception as e:
log.printerror_stacktrace(logger, e)
# We're done, call the run method of the done callback
done.run(response)
def open(self):
try:
shape = self.dct_resolution[self.dct_params.get("resolution").get()]
fps = self.dct_fps[self.dct_params.get("fps").get()]
self.video = cv2.VideoCapture(self.own_config.no)
self.video.set(cv2.cv.CV_CAP_PROP_FRAME_WIDTH, shape[0])
self.video.set(cv2.cv.CV_CAP_PROP_FRAME_HEIGHT, shape[1])
self.video.set(cv2.cv.CV_CAP_PROP_FPS, fps)
except Exception as e:
log.printerror_stacktrace(logger, "Open camera %s: %s" % (self.get_name(), e))
return False
# call open when video is ready
return Media_streaming.open(self)
def open(self):
try:
shape = self.dct_resolution[self.param_resolution.get()]
fps = self.dct_fps[self.param_fps.get()]
self.video = pygame.camera.Camera(self.own_config.path, shape)
self.video.start()
self.thread_image = True
thread.start_new_thread(self.update_image, ())
except BaseException as e:
log.printerror_stacktrace(
logger, "Open camera %s: %s" % (self.get_name(), e))
return False
# call open when video is ready
return MediaStreaming.open(self)
def reload_filter(self, controller, request, done):
logger.info("reload_filter request %s", str(request).replace("\n", " "))
# Create a reply
response = server_pb2.StatusResponse()
try:
self.manager.reload_filter(request.filterName[0])
response.status = 0
except Exception as e:
log.printerror_stacktrace(logger, e)
response.status = -1
# We're done, call the run method of the done callback
done.run(response)
def need_notify(self, controller, request, done):
# logger.debug("need_notify request %s", str(request).replace("\n", " "))
# Create a reply
response = server_pb2.StatusResponse()
try:
status = self.manager.need_notify(request.id)
response.status = not(status)
except Exception as e:
log.printerror_stacktrace(logger, e)
response.status = -1
# We're done, call the run method of the done callback
done.run(response)
def is_connected(self):
if not self.quiet:
logger.info("Try connection")
request = server_pb2.IsConnectedRequest()
# Make an synchronous call
response = None
try:
response = self.service.is_connected(request, timeout=10000) is not None
if response and not self.quiet:
logger.info("Connection successful")
except Exception as e:
log.printerror_stacktrace(logger, e)
return response
def get_filter_list(self):
"""
Return list of filter
"""
request = server_pb2.GetFilterListRequest()
# Make an synchronous call
returnValue = None
try:
response = self.service.get_filter_list(request, timeout=10000)
returnValue = {response.filters[i]:response.doc[i] for i in range(len(response.filters))}
except Exception as e:
log.printerror_stacktrace(logger, e)
return returnValue
def add_notify_server(self):
request = server_pb2.AddNotifyRequest()
# Make an synchronous call
id = None
try:
response = self.service.add_notify_server(request, timeout=10000)
if response:
id = response.id
if id < 0:
id = None
except Exception as e:
log.printerror_stacktrace(logger, e)
return id
def get_info_media(self, media_name):
request = server_pb2.GetInfoMediaRequest()
request.media_name = media_name
# Make an synchronous call
dct_message = {}
try:
response = self.service.get_info_media(request, timeout=10000)
if response:
message = response.message
if message:
dct_message = json.loads(message)
except Exception as e:
log.printerror_stacktrace(logger, e)
return dct_message
def get_real_fps_execution(self, execution_name):
request = server_pb2.GetRealFpsExecutionRequest()
request.execution_name = execution_name
# Make an synchronous call
try:
response = self.service.get_real_fps_execution(request, timeout=10000)
if not response:
fps = -1
else:
fps = response.fps
except Exception as e:
log.printerror_stacktrace(logger, e)
fps = -1
return fps
def _create_module(cpptimestamps, module, modname, mod, reload_mod=None):
try:
logger.info("Begin compile %s.", modname)
no_verbose = 3 if config.get_verbose() else 0
if modname in cpptimestamps:
# Reloaded modules are saved in the reload folder for easy cleanup
mod.compile(RELOAD_DIR, verbose=no_verbose)
else:
mod.compile(BUILD_DIR, verbose=no_verbose)
if reload_mod:
cppmodule = __import__(reload_mod)
else:
cppmodule = __import__(modname)
params = {}
init_attr = getattr(cppmodule, 'init_' + modname)
exec_attr = getattr(cppmodule, 'exec_' + modname)
dct_fct = {
'__init__':
create_init(init_attr, params),
'execute':
create_execute(exec_attr),
'py_init_param':
py_init_param,
'py_init_global_param':
py_init_global_param,
'set_original_image':
create_set_original_image(
getattr(cppmodule, 'set_original_image_' + modname)),
'set_global_params_cpp':
create_set_global_params(
getattr(cppmodule, 'set_global_params_' + modname)),
'__doc__':
getattr(cppmodule, 'help_' + modname)()
}
if has_configure:
dct_fct['configure'] = create_configure(
getattr(cppmodule, 'config_' + modname))
if has_destroy:
dct_fct['destroy'] = create_destroy(
getattr(cppmodule, 'destroy_' + modname))
clazz = type(modname, (Filter, ), dct_fct)
clazz.__module_init__ = module
setattr(module, modname, clazz)
del clazz
except BaseException as e:
log.printerror_stacktrace(logger, e)
def open(self):
try:
shape = self.dct_resolution[self.param_resolution.get()]
fps = self.dct_fps[self.param_fps.get()]
# TODO check argument video capture
self.video = cv2.VideoCapture(self.own_config.no)
self.video.set(cv2.cv.CV_CAP_PROP_FRAME_WIDTH, shape[0])
self.video.set(cv2.cv.CV_CAP_PROP_FRAME_HEIGHT, shape[1])
self.video.set(cv2.cv.CV_CAP_PROP_FPS, fps)
except BaseException as e:
log.printerror_stacktrace(
logger, "Open camera %s: %s" % (self.get_name(), e))
return False
# call open when video is ready
return MediaStreaming.open(self)
def run(p_port=None, verbose=False, config_path=None):
global config
config = Configuration(config_path=config_path)
path = config.get_log_file_path()
# choose the log file path
if path:
log.add_handler(path)
config.set_verbose(verbose)
# recheck if its locked because the last check is maybe a false lock
pid = os.getpid()
file_lock_path = "/tmp/SeaGoat.lock"
if is_lock(file_lock_path):
sys.exit(-1)
file_lock = open(file_lock_path, "w")
file_lock.write("%s" % pid)
file_lock.close()
if not p_port:
port = config.get_tcp_output_config()
else:
port = p_port
# Create and register the service
server = jsonrpc_server.JsonrpcServer(port)
try:
server.register()
except BaseException as e:
log.printerror_stacktrace(logger, e)
server.close()
sys.exit(1)
# Start the server
logger.info('Serving on port %s - pid %s', port, pid)
logger.info('Waiting command')
try:
server.run()
except (KeyboardInterrupt, SystemExit):
logger.info("Close SeaGoat. See you later!")
except BaseException:
raise
finally:
server.close()
# force closing the file
os.remove(file_lock_path)
def execute(self, image):
original_image = np.copy(image)
# first image observator
if self.original_image_observer:
self.send_image(original_image, self.original_image_observer)
try:
for f in self.filters:
if f.get_is_active():
f.set_original_image(original_image)
image = f.execute(image)
lst_observer = self.image_observers.get(f.get_name(), [])
if lst_observer:
self.send_image(image, lst_observer)
except BaseException as e:
msg = "(Exec exception Filter %s) %s" % (f.get_name(), e)
log.printerror_stacktrace(logger, msg, check_duplicate=True)
return image
def update_image(self, image):
self.light_observer.active_light()
# fps
actual_time = time.time()
if self.last_second_fps is None:
# Initiate fps
self.last_second_fps = actual_time
self.fps_count = 1
elif actual_time - self.last_second_fps > 1.0:
self.ui.lbl_stream_fps.setText("%d" % int(self.fps_count))
# new set
self.last_second_fps = actual_time
self.fps_count = 1
else:
self.fps_count += 1
try:
self.numpy_to_qimage(image)
except BaseException as e:
log.printerror_stacktrace(logger, e, check_duplicate=True)
def _create_params(self):
if not self.camera:
return
group_name_color = "Color"
group_name_shutter = "Shutter"
lst_ignore_prop = ["Trigger"]
dct_prop = self.camera.get_dict_available_features()
for name, value in dct_prop.items():
if name in lst_ignore_prop:
continue
try:
if name == "White Balance":
# add auto white balance
param = Param("%s%s" % (name, self.key_auto_param), False)
param.add_notify(self.update_property_param)
param.add_group(group_name_color)
param.add_notify(self._trig_auto_whitebalance)
self.add_param(param)
# add specific color of white balance
param = Param(
"RV_value",
value["RV_value"],
min_v=value["min"],
max_v=value["max"])
param.set_description("%s-red" % name)
param.add_notify(self.update_property_param)
param.add_group(group_name_color)
self.lst_param_whitebalance.append(param)
self.add_param(param)
param = Param(
"BU_value",
value["BU_value"],
min_v=value["min"],
max_v=value["max"])
param.set_description("%s-blue" % name)
param.add_notify(self.update_property_param)
self.lst_param_whitebalance.append(param)
param.add_group(group_name_color)
self.add_param(param)
continue
param = Param(
name,
value["value"],
min_v=value["min"],
max_v=value["max"])
param.add_notify(self.update_property_param)
self.add_param(param)
if name == "Shutter":
self.lst_param_shutter.append(param)
param.add_group(group_name_shutter)
# add auto param
param = Param("%s%s" % (name, self.key_auto_param), False)
param.add_notify(self._trig_auto_shutter)
param.add_notify(self.update_property_param)
param.add_group(group_name_shutter)
self.add_param(param)
except BaseException as e:
log.printerror_stacktrace(
logger, "%s - name: %s, value: %s" % (e, name, value))
# add operational param
group_operation = "operation"
self.param_power = Param("Power", True)
self.param_power.add_notify(self._power)
self.param_power.add_group(group_operation)
self.param_transmission = Param("Transmission", False)
self.param_transmission.add_notify(self._transmission)
self.param_transmission.add_group(group_operation)
self.sync_params()
