The Configuration Viewer is a powerful tool in KOS Studio that allows you to view and modify configuration parameters for your running application without rebuilding or redeploying. When developing software that interacts with hardware, timings and other settings often need fine-tuning. Instead of repeatedly modifying code, rebuilding, and redeploying,which consumes valuable time and resources,the Configuration Viewer lets you adjust parameters on the fly and see changes take effect immediately on your running device or simulator.
This tool provides a centralized interface for managing all configurable parameters (configs) defined in your application, making it easy to experiment with different values, optimize performance, and troubleshoot issues in real-time.
Understanding KOS Configurations
Before using the Configuration Viewer, it’s helpful to understand how the KOS configuration system works.
What Are Configs?
Configs are configurable parameters that developers define in their code to control various aspects of application behavior. Common examples include:
- Timing values for operations
- Threshold settings for features, hardwares, sensors
- Boolean flags to enable or disable features
- Numeric parameters for calculations or algorithms
- String values for labels or identifiers
These configs are defined in special classes called ConfigBeans and can be modified through the Configuration Viewer without changing code.
ConfigBeans and Config Properties
ConfigBeans are classes that store collections of related configuration parameters. An application typically has multiple ConfigBeans,for example, the main Application class might have its own ConfigBean, and each hardware component in the system might have separate ConfigBeans for their specific settings.
Config Properties are the individual parameters called Attribute within a ConfigBean. Each property (attribute) has:
- A name (displayed as a dot-annotated path in the Configuration Viewer)
- A current value, displayed as toggle for boolean values and entry box for all other types.
- A description explaining its purpose
ConfigService
The ConfigService acts as the central manager for all configuration data. It ensures that when you change a config value in the Configuration Viewer, that change is immediately applied to the correct object in your running application. This happens automatically,you don’t need to restart the application or take any additional action.
Immediate Effect
One of the most powerful aspects of the configuration system is that changes take effect immediately. When you modify a config value and apply the change, the running application receives the update instantly. This allows you to:
- Experiment with different values in real-time
- Fine-tune timings while watching hardware behavior
- Enable or disable features to isolate issues
- Optimize parameters based on live feedback
Accessing the Configuration Viewer
Opening the Tool
- Log into KOS Studio
- In the Connection Manager window, locate your running image (connected to a simulator or device)
- Find the Active Tools section for that connection
- Click + Start New Tool
- Select Configuration Viewer from the dropdown menu
Note: The Configuration Viewer is only available for active connections to running images or devices.
Understanding the Configuration Viewer Interface
The Configuration Viewer organizes configuration parameters in a structured, hierarchical view that makes it easy to find and modify the settings you need.
Config Paths
Config paths are displayed on the left navigation bar and they can be expanded and collapsed based on their hierarchy. Each path can have one or multiple config properties.
When selected, for each config property, the Configuration Viewer shows:
- The full Config path
- Name of the property
- The current value
- The property description (explaining its purpose)
- The data type (integer, boolean, string, etc.)
- Units (if applicable, such as milliseconds, degrees, or percentages)
Searching for Config Properties
To quickly find specific configuration parameters:
- Use the Search box at the top of the Configuration Viewer
- Type a search term related to the config you’re looking for
- The view updates to show only matching config properties
Search Behavior:
Single Term Search:
The Configuration Viewer searches for one term at a time. When you enter a search term, it looks for matches in:
- Config property paths
- Config property name
- Config descriptions
Case Sensitivity:
Search is typically case-insensitive, allowing you to search for “timeout”, “Timeout”, or “TIMEOUT” with the same results.
Partial Matching:
The search finds partial matches, so searching for “temp” will find properties like:
- sensor.temperature.threshold
- pump.temp.max
- system.tempControl.enabled
Clearing Search:
Remove your search term or clear the search box to see all available config properties again.
Example Use Cases:
- Search for “timeout” to find all timing-related configs
- Search for “enabled” to find all feature flags
- Search for “pump” to find all pump-related settings
- Search for “threshold” to find all threshold values
Viewing Config Properties
Browsing by Path
To explore configs organized by their path:
- Browse the list of Config Paths in the Configuration Viewer
- Expand a path to see its config properties
- Collapse path you’re not interested in to reduce clutter
This hierarchical view makes it easy to focus on specific areas of your application’s configuration.
Understanding Property Information
When you view a config property, pay attention to all the displayed information:
Config Path:
The full dot-annotated path tells you exactly where this config exists in your application’s configuration hierarchy. This is useful for understanding which component or feature the config controls.
Config Name:
Config name allows user to see the name of the property as defined in the application.
Description:
Read the description carefully,it explains what the config does, when to use it, and sometimes includes important warnings or considerations.
Current Value:
The current value shows what the config is set to right now in the running application. This is the live value that’s actively being used.
Modifying Config Properties
Changing a Value
To modify a config property:
- Locate the config property you want to change (using search or browsing)
- Click on the property to select it
- Enter the new value in the input field
- The interface will validate that the value matches the expected data type
- Apply or save the change (depending on the interface design)
- The new value is immediately sent to the running application
Immediate Effect:
Once you apply the change, the running application receives the update instantly. You should see the effect of the change in real-time without needing to restart anything.
Value Validation
The Configuration Viewer performs basic validation to ensure you enter appropriate values:
Type Checking:
- Integer fields reject non-numeric input
- Boolean fields typically provide a checkbox or true/false selector
- Numeric fields with units check that you provide numbers
Understanding Configuration Changes
When you modify a config:
Immediate Application:
The ConfigService ensures the change is applied to the correct object in your running application immediately. The application begins using the new value right away.
Callback Execution:
If the application code has registered listeners for config changes, those callbacks execute when you modify a value, allowing the application to respond appropriately to the change.
Practical Usage Scenarios
Fine-Tuning Hardware Timings
When hardware operations need timing adjustments:
- Open Configuration Viewer on your running device
- Search for timing-related configs (e.g., “timeout”, “delay”, “duration”)
- Note the current values and units
- Modify the timing value to test different settings
- Observe the hardware behavior in real-time
- Iterate until you find the optimal value
- Document the final value for updating in code
Enabling/Disabling Features for Testing
To isolate issues or test specific features:
- Search for feature flags (e.g., “enabled”, “active”, “use”)
- Toggle boolean configs to enable or disable features
- Test application behavior with features on or off
- Identify which features contribute to issues
- Re-enable features incrementally to isolate problems
Adjusting Thresholds and Limits
When calibrating sensor thresholds or operational limits:
- Search for threshold or limit configs
- View current threshold values
- Modify thresholds based on observed behavior
- Watch for warnings, errors, or state changes
- Fine-tune until behavior matches requirements
- Record optimal values for permanent configuration
Experimenting with Parameters
During development or optimization:
- Identify configs related to the area you’re optimizing
- Change values one at a time
- Observe the impact on application behavior or performance
- Try various combinations to find optimal settings
- Use search to quickly locate related configs
- Document successful parameter combinations
Debugging Configuration Issues
When you suspect configuration problems:
- Search for configs related to the problematic area
- Verify current values match expectations
- Check if overrides might have changed expected values
- Try reverting to known-good values
- Modify configs to isolate the issue
- Trace config changes by observing immediate effects
Tips for Effective Use
- Read descriptions carefully: Config descriptions often contain important usage notes, valid ranges, and warnings
- Understand units: Pay close attention to units (milliseconds vs. seconds, degrees vs. radians, etc.)
- Use search effectively: Think about keywords that might appear in both property paths and descriptions
- Watch for immediate effects: Pay attention to application behavior right after applying changes
- Understand the hierarchy: The dot-annotated paths tell you where configs live in your application’s structure
- Verify data types: Make sure your values match the expected type to avoid validation errors