cfclient 2017.4__py3-none-any.whl → 2025.12.1__py3-none-any.whl

cfclient/utils/input/__init__.py

@@ -67,6 +67,7 @@ MAX_THRUST = 65000
 INITAL_TAGET_HEIGHT = 0.4
 MAX_TARGET_HEIGHT = 1.0
 MIN_TARGET_HEIGHT = 0.03
+MIN_HOVER_HEIGHT = 0.20
 INPUT_READ_PERIOD = 0.01
 
 
@@ -80,6 +81,7 @@ class JoystickReader(object):
     ASSISTED_CONTROL_ALTHOLD = 0
     ASSISTED_CONTROL_POSHOLD = 1
     ASSISTED_CONTROL_HEIGHTHOLD = 2
+    ASSISTED_CONTROL_HOVER = 3
 
     def __init__(self, do_device_discovery=True):
         self._input_device = None
@@ -95,6 +97,7 @@ class JoystickReader(object):
         self.thrust_slew_enabled = False
         self.thrust_slew_limit = 0
         self.has_pressure_sensor = False
+        self._hover_max_height = MAX_TARGET_HEIGHT
 
         self.max_rp_angle = 0
         self.max_yaw_rate = 0
@@ -110,10 +113,11 @@ class JoystickReader(object):
 
         self.trim_roll = Config().get("trim_roll")
         self.trim_pitch = Config().get("trim_pitch")
+        self._rp_dead_band = 0.1
 
         self._input_map = None
 
-        if Config().get("flightmode") is "Normal":
+        if Config().get("flightmode") == "Normal":
             self.max_yaw_rate = Config().get("normal_max_yaw")
             self.max_rp_angle = Config().get("normal_max_rp")
             # Values are stored at %, so use the functions to set the values
@@ -165,8 +169,10 @@ class JoystickReader(object):
         self.input_updated = Caller()
         self.assisted_input_updated = Caller()
         self.heighthold_input_updated = Caller()
+        self.hover_input_updated = Caller()
         self.rp_trim_updated = Caller()
         self.emergency_stop_updated = Caller()
+        self.arm_updated = Caller()
         self.device_discovery = Caller()
         self.device_error = Caller()
         self.assisted_control_updated = Caller()
@@ -183,6 +189,9 @@ class JoystickReader(object):
                 return d
         return None
 
+    def set_hover_max_height(self, height):
+        self._hover_max_height = height
+
     def set_alt_hold_available(self, available):
         """Set if altitude hold is available or not (depending on HW)"""
         self.has_pressure_sensor = available
@@ -295,13 +304,17 @@ class JoystickReader(object):
 
     def set_input_map(self, device_name, input_map_name):
         """Load and set an input device map with the given name"""
+        dev = self._get_device_from_name(device_name)
         settings = ConfigManager().get_settings(input_map_name)
+
         if settings:
             self.springy_throttle = settings["springythrottle"]
+            self._rp_dead_band = settings["rp_dead_band"]
             self._input_map = ConfigManager().get_config(input_map_name)
-        self._get_device_from_name(device_name).input_map = self._input_map
-        self._get_device_from_name(device_name).input_map_name = input_map_name
+        dev.input_map = self._input_map
+        dev.input_map_name = input_map_name
         Config().get("device_config_mapping")[device_name] = input_map_name
+        dev.set_dead_band(self._rp_dead_band)
 
     def start_input(self, device_name, role="Device", config_name=None):
         """
@@ -356,17 +369,30 @@ class JoystickReader(object):
             if data:
                 if data.toggled.assistedControl:
                     if self._assisted_control == \
-                            JoystickReader.ASSISTED_CONTROL_POSHOLD:
-                        if data.assistedControl:
+                            JoystickReader.ASSISTED_CONTROL_POSHOLD or \
+                            self._assisted_control == \
+                            JoystickReader.ASSISTED_CONTROL_HOVER:
+                        if data.assistedControl and self._assisted_control != \
+                                JoystickReader.ASSISTED_CONTROL_HOVER:
                             for d in self._selected_mux.devices():
                                 d.limit_thrust = False
                                 d.limit_rp = False
+                        elif data.assistedControl:
+                            for d in self._selected_mux.devices():
+                                d.limit_thrust = True
+                                d.limit_rp = False
                         else:
                             for d in self._selected_mux.devices():
                                 d.limit_thrust = True
                                 d.limit_rp = True
                     if self._assisted_control == \
-                            JoystickReader.ASSISTED_CONTROL_HEIGHTHOLD:
+                            JoystickReader.ASSISTED_CONTROL_ALTHOLD:
+                        self.assisted_control_updated.call(
+                                            data.assistedControl)
+                    if ((self._assisted_control ==
+                            JoystickReader.ASSISTED_CONTROL_HEIGHTHOLD) or
+                            (self._assisted_control ==
+                             JoystickReader.ASSISTED_CONTROL_HOVER)):
                         try:
                             self.assisted_control_updated.call(
                                                 data.assistedControl)
@@ -379,6 +405,9 @@ class JoystickReader(object):
                                 self.heighthold_input_updated.\
                                     call(0, 0,
                                          0, INITAL_TAGET_HEIGHT)
+                                self.hover_input_updated.\
+                                    call(0, 0,
+                                         0, INITAL_TAGET_HEIGHT)
                         except Exception as e:
                             logger.warning(
                                 "Exception while doing callback from "
@@ -391,7 +420,12 @@ class JoystickReader(object):
                     except Exception as e:
                         logger.warning("Exception while doing callback from"
                                        "input-device for estop: {}".format(e))
-
+                if data.toggled.arm and data._prev_btn_values["arm"]:
+                    try:
+                        self.arm_updated.call(data.arm)
+                    except Exception as e:
+                        logger.warning("Exception while doing callback from"
+                                       "input-device for arm: {}".format(e))
                 if data.toggled.alt1:
                     try:
                         self.alt1_updated.call(data.alt1)
@@ -406,8 +440,11 @@ class JoystickReader(object):
                                        "input-device for alt2: {}".format(e))
 
                 # Reset height target when height-hold is not selected
-                if not data.assistedControl or self._assisted_control != \
-                        JoystickReader.ASSISTED_CONTROL_HEIGHTHOLD:
+                if not data.assistedControl or \
+                        (self._assisted_control !=
+                         JoystickReader.ASSISTED_CONTROL_HEIGHTHOLD and
+                         self._assisted_control !=
+                         JoystickReader.ASSISTED_CONTROL_HOVER):
                     self._target_height = INITAL_TAGET_HEIGHT
 
                 if self._assisted_control == \
@@ -416,20 +453,41 @@ class JoystickReader(object):
                     vx = data.roll
                     vy = data.pitch
                     vz = data.thrust
-                    yawrate = data.yaw
+                    yawrate = -data.yaw
                     # The odd use of vx and vy is to map forward on the
-                    # physical joystick to positiv X-axis
+                    # physical joystick to positive X-axis
                     self.assisted_input_updated.call(vy, -vx, vz, yawrate)
+                elif self._assisted_control == \
+                        JoystickReader.ASSISTED_CONTROL_HOVER \
+                        and data.assistedControl:
+                    vx = data.roll
+                    vy = data.pitch
+
+                    # Scale thrust to a value between -1.0 to 1.0
+                    vz = (data.thrust - 32767) / 32767.0
+                    # Integrate velocity setpoint
+                    self._target_height += vz * INPUT_READ_PERIOD
+                    # Cap target height
+                    if self._target_height > self._hover_max_height:
+                        self._target_height = self._hover_max_height
+                    if self._target_height < MIN_HOVER_HEIGHT:
+                        self._target_height = MIN_HOVER_HEIGHT
+
+                    yawrate = -data.yaw
+                    # The odd use of vx and vy is to map forward on the
+                    # physical joystick to positive X-axis
+                    self.hover_input_updated.call(vy, -vx, yawrate,
+                                                  self._target_height)
                 else:
                     # Update the user roll/pitch trim from device
                     if data.toggled.pitchNeg and data.pitchNeg:
-                        self.trim_pitch -= 1
+                        self.trim_pitch -= .2
                     if data.toggled.pitchPos and data.pitchPos:
-                        self.trim_pitch += 1
+                        self.trim_pitch += .2
                     if data.toggled.rollNeg and data.rollNeg:
-                        self.trim_roll -= 1
+                        self.trim_roll -= .2
                     if data.toggled.rollPos and data.rollPos:
-                        self.trim_roll += 1
+                        self.trim_roll += .2
 
                     if data.toggled.pitchNeg or data.toggled.pitchPos or \
                             data.toggled.rollNeg or data.toggled.rollPos:
@@ -441,14 +499,14 @@ class JoystickReader(object):
                             and data.assistedControl:
                         roll = data.roll + self.trim_roll
                         pitch = data.pitch + self.trim_pitch
-                        yawrate = data.yaw
+                        yawrate = -data.yaw
                         # Scale thrust to a value between -1.0 to 1.0
                         vz = (data.thrust - 32767) / 32767.0
-                        # Integrate velosity setpoint
+                        # Integrate velocity setpoint
                         self._target_height += vz * INPUT_READ_PERIOD
                         # Cap target height
-                        if self._target_height > MAX_TARGET_HEIGHT:
-                            self._target_height = MAX_TARGET_HEIGHT
+                        if self._target_height > self._hover_max_height:
+                            self._target_height = self._hover_max_height
                         if self._target_height < MIN_TARGET_HEIGHT:
                             self._target_height = MIN_TARGET_HEIGHT
                         self.heighthold_input_updated.call(roll, -pitch,

cfclient/utils/input/inputinterfaces/wiimote.py

@@ -24,7 +24,7 @@ class _Reader(object):
 
     def devices(self):
         """List all the available connections"""
-        raise NotImplemented()
+        raise NotImplementedError
 
     def open(self, device_id):
         """
@@ -38,7 +38,7 @@ class _Reader(object):
 
     def read(self, device_id):
         """Read input from the selected device."""
-        raise NotImplemented()
+        raise NotImplementedError
 
 
 TWO = 1

cfclient/utils/input/inputreaderinterface.py

@@ -50,9 +50,9 @@ class InputData:
     def __init__(self):
         # self._toggled = {}
         self._axes = ("roll", "pitch", "yaw", "thrust")
-        self._buttons = ("alt1", "alt2", "estop", "exit", "pitchNeg",
-                         "pitchPos", "rollNeg", "rollPos", "assistedControl",
-                         "muxswitch")
+        self._buttons = ("pitchNeg", "pitchPos", "rollNeg", "rollPos",
+                         "assistedControl", "estop", "arm",
+                         "exitapp", "alt1", "alt2", "muxswitch")
         for axis in self._axes:
             self.__dict__[axis] = 0.0
         self.toggled = _ToggleState()
@@ -165,15 +165,25 @@ class InputReaderInterface(object):
                 self.input.max_yaw_rate)
 
     def _limit_thrust(self, thrust, assisted_control, emergency_stop):
-        # Thust limiting (slew, minimum and emergency stop)
+        # Thrust limiting (slew, minimum and emergency stop)
+
+        current_time = time()
         if self.input.springy_throttle:
             if assisted_control and \
                     (self.input.get_assisted_control() ==
                      self.input.ASSISTED_CONTROL_ALTHOLD or
                      self.input.get_assisted_control() ==
-                     self.input.ASSISTED_CONTROL_HEIGHTHOLD):
+                     self.input.ASSISTED_CONTROL_HEIGHTHOLD or
+                     self.input.get_assisted_control() ==
+                     self.input.ASSISTED_CONTROL_HOVER):
                 thrust = int(round(InputReaderInterface.deadband(thrust, 0.2) *
                                    32767 + 32767))  # Convert to uint16
+
+                # do not drop thrust to 0 after switching hover mode off
+                # set previous values for slew limit logic
+                self._prev_thrust = self.input.thrust_slew_limit
+                self._last_time = current_time
+
             else:
                 # Scale the thrust to percent (it's between 0 and 1)
                 thrust *= 100
@@ -197,7 +207,7 @@ class InputReaderInterface(object):
                         else:
                             # If we are "inside" the limit, then lower
                             # according to the rate we have set each iteration
-                            lowering = ((time() - self._last_time) *
+                            lowering = ((current_time - self._last_time) *
                                         self.input.thrust_slew_rate)
                             limited_thrust = self._prev_thrust - lowering
                 elif emergency_stop or thrust < self.thrust_stop_limit:
@@ -216,7 +226,7 @@ class InputReaderInterface(object):
                     self._prev_thrust = 0
                     limited_thrust = 0
 
-                self._last_time = time()
+                self._last_time = current_time
 
                 thrust = limited_thrust
         else:

cfclient/utils/input/inputreaders/__init__.py

@@ -92,6 +92,7 @@ class InputDevice(InputReaderInterface):
         self.limit_rp = True
         self.limit_thrust = True
         self.limit_yaw = True
+        self.db = 0.
 
     def open(self):
         # TODO: Reset data?
@@ -100,6 +101,9 @@ class InputDevice(InputReaderInterface):
     def close(self):
         self._reader.close(self.id)
 
+    def set_dead_band(self, db):
+        self.db = db
+
     def read(self, include_raw=False):
         [axis, buttons] = self._reader.read(self.id)
 
@@ -135,6 +139,9 @@ class InputDevice(InputReaderInterface):
                 pass
             i += 1
 
+        self.data.roll = InputDevice.deadband(self.data.roll, self.db)
+        self.data.pitch = InputDevice.deadband(self.data.pitch, self.db)
+
         if self.limit_rp:
             [self.data.roll, self.data.pitch] = self._scale_rp(self.data.roll,
                                                                self.data.pitch)
@@ -149,3 +156,13 @@ class InputDevice(InputReaderInterface):
             return [axis, buttons, self.data]
         else:
             return self.data
+
+    @staticmethod
+    def deadband(value, threshold):
+        if abs(value) < threshold:
+            value = 0
+        elif value > 0:
+            value -= threshold
+        elif value < 0:
+            value += threshold
+        return value / (1 - threshold)

cfclient/utils/logconfigreader.py

@@ -7,7 +7,7 @@
 #  +------+    / /_/ / / /_/ /__/ /  / /_/ / / /_/  __/
 #   ||  ||    /_____/_/\__/\___/_/   \__,_/ /___/\___/
 #
-#  Copyright (C) 2011-2013 Bitcraze AB
+#  Copyright (C) 2011-2024 Bitcraze AB
 #
 #  Crazyflie Nano Quadcopter Client
 #
@@ -27,59 +27,267 @@
 #  MA  02110-1301, USA.
 
 """
-The input module that will read joysticks/input devices and send control set-
-points to the Crazyflie. It will also accept settings from the UI.
-
-This module can use different drivers for reading the input device data.
-Currently it can just use the PySdl2 driver but in the future there will be a
-Linux and Windows driver that can bypass PySdl2.
+The logconfigreader module is responsible for reading and parsing log
+configuration data. This data is used to control what information is logged
+in the client.
 """
 
-import glob
 import json
 import logging
 import os
+import re
 import shutil
 
 import cfclient
 from cflib.crazyflie.log import LogVariable, LogConfig
 
+from PyQt6 import QtGui
+
 __author__ = 'Bitcraze AB'
 __all__ = ['LogVariable', 'LogConfigReader']
 
 logger = logging.getLogger(__name__)
 
+DEFAULT_CONF_NAME = 'log_config'
+DEFAULT_CATEGORY_NAME = 'category'
+
+FILE_REGEX_YAML = "Config *.yaml;;All *.*"
+
 
 class LogConfigReader():
     """Reads logging configurations from file"""
 
     def __init__(self, crazyflie):
+
+        self._log_configs = {}
         self.dsList = []
         # Check if user config exists, otherwise copy files
         if (not os.path.exists(cfclient.config_path + "/log")):
             logger.info("No user config found, copying dist files")
-            os.makedirs(cfclient.config_path + "/log")
-            for f in glob.glob(
-                    cfclient.module_path + "/configs/log/[A-Za-z]*.json"):
-                shutil.copy2(f, cfclient.config_path + "/log")
+            shutil.copytree(cfclient.module_path + "/configs/log", cfclient.config_path + "/log")
         self._cf = crazyflie
         self._cf.connected.add_callback(self._connected)
 
+    def get_icons(self):
+        client_path = os.path.abspath(os.path.join(os.path.dirname(__file__),
+                                      os.pardir))
+        icon_path = os.path.join(client_path, 'ui', 'icons')
+        save_icon = QtGui.QIcon(os.path.join(icon_path, 'create.png'))
+        delete_icon = QtGui.QIcon(os.path.join(icon_path, 'delete.png'))
+        return save_icon, delete_icon
+
+    def create_empty_log_conf(self, category):
+        """ Creates an empty log-configuration with a default name """
+        log_path = self._get_log_path(category)
+        conf_name = self._get_default_conf_name(log_path)
+        file_path = os.path.join(log_path, conf_name) + '.json'
+
+        if not os.path.exists(file_path):
+            with open(file_path, 'w') as f:
+                f.write(json.dumps(
+                    {
+                        'logconfig': {
+                            'logblock': {
+                                'variables': [],
+                                'name': conf_name,
+                                'period': 100
+                            }
+                        }
+                    }, indent=2))
+
+        self._log_configs[category].append(LogConfig(conf_name, 100))
+        return conf_name
+
+    def create_category(self):
+        """ Creates a new category (dir in filesystem), with a unique name """
+        log_path = os.path.join(cfclient.config_path, 'log')
+        category = self._get_default_category(log_path)
+        dir_path = os.path.join(log_path, category)
+
+        # This should never be false, but just to be safe.
+        if not os.path.exists(dir_path):
+            os.mkdir(dir_path)
+            self._log_configs[category] = []
+
+        return category
+
+    def delete_category(self, category):
+        """ Removes the directory on file-system and recursively removes
+            all the logging configurations.
+        """
+        log_path = self._get_log_path(category)
+        if os.path.exists(log_path):
+            shutil.rmtree(log_path)
+            self._log_configs.pop(category)
+
+    def delete_config(self, conf_name, category):
+        """ Deletes a configuration from file system. """
+        log_path = self._get_log_path(category)
+        conf_path = os.path.join(log_path, conf_name) + '.json'
+
+        if not os.path.exists(conf_path):
+            # Check if we can find the file with lowercase first letter.
+            conf_path = os.path.join(log_path,
+                                     conf_name[0].lower() + conf_name[1:]
+                                     + '.json')
+            if not os.path.exists(conf_path):
+                # Cant' find the config-file
+                logger.warning('Failed to find log-config %s' % conf_path)
+                return
+
+        os.remove(conf_path)
+        for conf in self._log_configs[category]:
+            if conf.name == conf_name:
+                self._log_configs[category].remove(conf)
+
+    def change_name_config(self, old_name, new_name, category):
+        """ Changes name to the configuration and updates the
+            file in the file system.
+        """
+        configs = self._log_configs[category]
+
+        for conf in configs:
+            if conf.name == old_name:
+                conf.name = new_name
+
+        log_path = self._get_log_path(category)
+        old_path = os.path.join(log_path, old_name) + '.json'
+        new_path = os.path.join(log_path, new_name) + '.json'
+
+        # File should exist but just to be extra safe
+        if os.path.exists(old_path):
+            with open(old_path, 'r+') as f:
+                data = json.load(f)
+                data['logconfig']['logblock']['name'] = new_name
+                f.seek(0)
+                f.truncate()
+                f.write(json.dumps(data, indent=2))
+
+            os.rename(old_path, new_path)
+
+    def change_name_category(self, old_name, new_name):
+        """ Renames the directory on file system and the config dict """
+        if old_name in self._log_configs:
+            self._log_configs[new_name] = self._log_configs.pop(old_name)
+            os.rename(self._get_log_path(old_name),
+                      self._get_log_path(new_name))
+
+    def _get_log_path(self, category):
+        """ Helper method """
+        category_dir = '' if category == 'Default' else '/' + category
+        return os.path.join(cfclient.config_path,
+                            'log' + category_dir)
+
+    def _get_default_category(self, log_path):
+        """ Creates a name for the category, ending with a unique number. """
+        dirs = [dir_ for dir_ in os.listdir(log_path) if os.path.isdir(
+            os.path.join(log_path, dir_)
+        )]
+        config_nbrs = re.findall(r'(?<=%s)\d*' % DEFAULT_CATEGORY_NAME,
+                                 ' '.join(dirs))
+        config_nbrs = list(filter(len, config_nbrs))
+
+        if config_nbrs:
+            return DEFAULT_CATEGORY_NAME + str(
+                            max([int(nbr) for nbr in config_nbrs]) + 1)
+        else:
+            return DEFAULT_CATEGORY_NAME + '1'
+
+    def _read_config_categories(self):
+        """Read and parse log configurations"""
+
+        self._log_configs = {'Default': []}
+        log_path = os.path.join(cfclient.config_path, 'log')
+
+        for category in os.listdir(log_path):
+
+            category_path = os.path.join(log_path, category)
+
+            try:
+                if (os.path.isdir(category_path)):
+                    # create a new cathegory
+                    self._log_configs[category] = []
+                    for conf in os.listdir(category_path):
+                        if conf.endswith('.json'):
+                            conf_path = os.path.join(category_path, conf)
+                            log_conf = self._get_conf(conf_path)
+
+                        # add the log configuration to the cathegory
+                        self._log_configs[category].append(log_conf)
+
+                else:
+                    # if it's not a directory, the log config is placed
+                    # in the 'Default' cathegory
+                    if category_path.endswith('.json'):
+                        log_conf = self._get_conf(category_path)
+                        self._log_configs['Default'].append(log_conf)
+
+            except Exception as e:
+                logger.warning("Failed to open log config %s", e)
+
+    def _get_default_conf_name(self, log_path):
+        config_nbrs = re.findall(r'(?<=%s)\d*(?!=\.json)' % DEFAULT_CONF_NAME,
+                                 ' '.join(os.listdir(log_path)))
+        config_nbrs = list(filter(len, config_nbrs))
+
+        if config_nbrs:
+            return DEFAULT_CONF_NAME + str(
+                        max([int(nbr) for nbr in config_nbrs]) + 1)
+        else:
+            return DEFAULT_CONF_NAME + '1'
+
+    def _get_conf(self, conf_path):
+        with open(conf_path) as f:
+            data = json.load(f)
+            infoNode = data["logconfig"]["logblock"]
+
+            logConf = LogConfig(infoNode["name"],
+                                int(infoNode["period"]))
+            for v in data["logconfig"]["logblock"]["variables"]:
+                if v["type"] == "TOC":
+                    logConf.add_variable(str(v["name"]), v["fetch_as"])
+                else:
+                    logConf.add_variable("Mem", v["fetch_as"],
+                                         v["stored_as"],
+                                         int(v["address"], 16))
+            return logConf
+
+    def _get_configpaths_recursively(self):
+        """ Reads all configuration files from the log path and
+            returns a list of tuples with format:
+            (category/conf-name, absolute path).
+        """
+        logpath = os.path.join(cfclient.config_path, 'log')
+        filepaths = []
+
+        for files in os.listdir(logpath):
+            abspath = os.path.join(logpath, files)
+            if os.path.isdir(abspath):
+                for config in os.listdir(abspath):
+                    if config.endswith('.json'):
+                        filepaths.append(('/'.join([files, config]),
+                                         os.path.join(abspath, config)))
+            else:
+                if files.endswith('.json'):
+                    filepaths.append((files, os.path.join(abspath)))
+
+        return filepaths
+
     def _read_config_files(self):
         """Read and parse log configurations"""
-        configsfound = [os.path.basename(f) for f in
-                        glob.glob(cfclient.config_path +
-                                  "/log/[A-Za-z_-]*.json")]
+
+        configsfound = self._get_configpaths_recursively()
+
         new_dsList = []
         for conf in configsfound:
             try:
-                logger.info("Parsing [%s]", conf)
-                json_data = open(cfclient.config_path + "/log/%s" % conf)
+                logger.info("Parsing [%s]", conf[0])
+                json_data = open(conf[1])
                 self.data = json.load(json_data)
                 infoNode = self.data["logconfig"]["logblock"]
+                logConfName = conf[0].replace('.json', '')
 
-                logConf = LogConfig(infoNode["name"],
-                                    int(infoNode["period"]))
+                logConf = LogConfig(logConfName, int(infoNode["period"]))
                 for v in self.data["logconfig"]["logblock"]["variables"]:
                     if v["type"] == "TOC":
                         logConf.add_variable(str(v["name"]), v["fetch_as"])
@@ -97,6 +305,7 @@ class LogConfigReader():
         """Callback that is called once Crazyflie is connected"""
 
         self._read_config_files()
+        self._read_config_categories()
         # Just add all the configurations. Via callbacks other parts of the
         # application will pick up these configurations and use them
         for d in self.dsList:
@@ -111,10 +320,15 @@ class LogConfigReader():
         """Return the log configurations"""
         return self.dsList
 
-    def saveLogConfigFile(self, logconfig):
+    def _getLogConfigs(self):
+        """Return the log configurations"""
+        return self._log_configs
+
+    def saveLogConfigFile(self, category, logconfig):
         """Save a log configuration to file"""
-        filename = cfclient.config_path + "/log/" + logconfig.name + ".json"
-        logger.info("Saving config for [%s]", filename)
+        log_path = self._get_log_path(category)
+        file_path = os.path.join(log_path, logconfig.name) + '.json'
+        logger.info("Saving config for [%s]", file_path)
 
         # Build tree for JSON
         saveConfig = {}
@@ -133,6 +347,12 @@ class LogConfigReader():
 
         saveConfig['logconfig'] = logconf
 
-        json_data = open(filename, 'w')
-        json_data.write(json.dumps(saveConfig, indent=2))
-        json_data.close()
+        for old_conf in self._log_configs[category]:
+            if old_conf.name == logconfig.name:
+                self._log_configs[category].remove(old_conf)
+                self._log_configs[category].append(logconfig)
+
+        with open(file_path, 'w') as f:
+            f.write(json.dumps(saveConfig, indent=2))
+
+        self._read_config_files()