* feat: add checks for ROS 2 message type support
Implement validation functions to ensure message or service types are compliant with ROS 2 standards, enhancing compatibility and error handling when integrating ROS 1 and ROS 2 environments.
* build: update file globbing to include configure dependencies
Ensure source files are automatically detected during configuration by adding CONFIGURE_DEPENDS to the file globbing commands for C++ and Python files. This improves build reliability as it accounts for changes in the file structure.
* feat: add ROS2 message support and enhance publishing functionality
Implement functions to register, publish, and subscribe to ROS2 messages, improving interoperability with ROS2 systems. Adjust type support to handle both protobuf and ROS2 message types, streamlining the process of message serialization and ensuring robustness in message handling.
* feat: add HTTP and ROS2 example configurations and applications
Introduce example configurations and applications for both HTTP and ROS2 channels, enabling greater flexibility and showcasing the capabilities of the system for publishing and subscribing to messages.
* chore: disable unimplemented copy and move functions
Throw runtime errors for the unimplemented copy and move methods to ensure clarity on their current status and prevent accidental usage.
* feat: enhance message publishing with iteration and logging
Implement continuous publishing of messages with incremental identifiers in the publisher application. Update the subscriber to log message count, improving visibility into received messages.
* refactor: reorganize and encapsulate ROS2 message handling functionality
Streamline the handling of ROS2 messages by encapsulating related functionality into a new utility header file. This enhances code clarity and maintainability while adhering to best practices in modular design.
* refactor: streamline protobuf and ROS2 message publishing
Enhance context handling and unify publish type registration for better clarity and usability. Simplify serialization type management and improve the architecture for future extensions, particularly for messaging features.
* refactor: streamline messaging functions
Enhance message publishing by consolidating function calls and improving clarity. Update context handling to better support message serialization types, allowing for a more flexible interaction with both protobuf and ROS2 messages.
* refactor: simplify message subscription handling and reduce publish frequency
Adjust the message subscription method to handle both Protobuf and ROS2 message types more efficiently and eliminate redundant subscription functions. Decrease the publishing frequency in the example app for improved performance and readability.
* fix: remove unnecessary error message for ROS 1 type detection
Eliminate confusion by removing the printed warning about ROS 1 message types, as it was not providing significant value in handling unsupported types.
* docs: update README and add ros2 channel examples
Clarify publisher behavior in examples and provide comprehensive documentation for ros2 channel implementations.
* feat: support ros2 message types in aimrt_py channel
Add support for ros2 message types in the aimrt_py channel to enhance interoperability with ROS2-based applications.
* fix: improve error handling during ROS2 message serialization and deserialization
Enhance robustness by adding exception handling to ensure the process correctly handles serialization and deserialization failures, improving overall stability in handling ROS2 messages.
* fix: correct argument validation and formatting
Remove unnecessary whitespace and enhance error handling for argument types in the publishing function, ensuring clear type checking and preventing potential runtime errors.
* refactor: streamline message conversion logic
Simplify the conversion of ROS2 messages to Python objects by moving the conversion logic inline. This eliminates unnecessary function calls and improves performance while maintaining clarity in the subscription method.
* feat: add ROS2 support to Python runtime
Enable linking and compilation of ROS2 interfaces based on the build configuration. This improves flexibility by allowing the Python runtime to interface with ROS2 when needed, enhancing interoperability and feature set.
* feat: enhance message type handling for publishers and subscribers
Add utility functions to generate names for ROS2 and protobuf message types, centralizing logic for type name creation. Update the publisher and subscriber to utilize these functions, improving code readability and maintainability while ensuring accurate message type management.
* feat: update message types to use RosTestMsg for better compatibility
Register new message type RosTestMsg in both publisher and subscriber applications. Update data format for publishing events to improve clarity and consistency in message handling. Ensure proper setup in the shell scripts for localization configuration.
* chore: consolidate pybind11 includes
Simplify header files by removing redundant pybind11 includes, reducing clutter and improving maintainability.
* docs: add ROS2 message support details and example links
Enhance the documentation by including information on ROS2 message formats and how to generate corresponding Python code. This provides users with clearer guidance on integrating ROS2 functionality within the project.
* chore: update copyright information to reflect new authorship
Update copyright year and licensing information across multiple configuration files and application scripts to maintain proper attribution for the AimRT project.
* feat: add ROS2 RPC client and server examples with configurations
Introduce example applications for ROS2 RPC communication, including client and server scripts, along with necessary configuration files. Implement a build script to set up the protocol buffers correctly, enhancing usability by supporting both HTTP and gRPC backends.
* feat: update RPC request and response handling
Refactor the RPC client and server implementations to utilize the updated request and response types from the example ROS2 service, improving code clarity and ensuring compatibility with the new service structure.
* refactor: simplify RPC response handling
Remove unnecessary response object instantiation and streamline the response creation process for improved clarity and efficiency in the RPC invocation logic.
* refactor: streamline publisher and subscriber method names
Simplify method names related to publishing and subscribing to enhance readability and maintainability. Transition from a prefix-based naming convention to a more concise approach, ensuring consistency across the codebase.
* chore: update configuration file paths for gRPC client and server examples
Align the configuration file paths in the example scripts to use the gRPC-specific settings, ensuring the correct configuration is utilized for both the client and server.
* refactor: rename internal methods for clarity
Improve naming conventions for protobuf message type functions, enhancing code readability and maintainability. Update related usages to keep consistent across the runtime and RPC generator.
* feat: add service type validation and improve bash scripts
Introduce a new bash script for debugging the ROS2 client and enhance existing scripts with proper sourcing. Implement service type validation to ensure the reliability of service registration. This improves the robustness of RPC interactions and simplifies the setup process for developers.
* feat: extend RPC response data structure and improve logging
Add additional data types to the RosTestRpc response for enhanced functionality. Set logging level to trace for more detailed output during execution.
* feat: add support for static and dynamic arrays in RPC service
Enhance the RPC service by introducing static and dynamic array types for various data types, enabling more complex data handling in requests and responses. This improves flexibility and usability for clients interacting with the service.
* feat: add support for new ROS message types
Enhance the RPC server to handle additional ROS message types, including dynamic and static arrays of custom data structures. This improves the server's data handling capabilities and aligns with the updated service specifications.
* refactor: improve type mapping and message copy functions
Update type mappings for better consistency and clarity. Enhance the readability of message copying functions by formatting multi-line expressions.
* refactor: improve message copying and moving functions
Enhance the handling of ROS message copying and moving by updating the parameter order and adding tailored move functions for better memory management. This optimizes the performance of message manipulations and ensures cleaner, more maintainable code.
* refactor: simplify message type support functions
Remove inline implementations and enhance readability of message type support functions, while maintaining functionality and improving code organization.
* refactor: streamline ROS message handling and improve introspection support
Enhance readability and maintainability by cleaning up function definitions related to ROS message type support. Implement a more robust method for obtaining message members information, addressing potential failure scenarios. Adjust example service implementation for consistency in dynamic data handling.
* fix: ensure pointers for ROS message creation and destruction are valid
Throw runtime exceptions if the function pointers for creating or destroying ROS messages are null, enhancing error handling and stability during object initialization.
* feat: enhance RosTestRpc method signature for better type safety
Improve the RosTestRpc method by adding overloads for different argument configurations, ensuring clearer type expectations and reducing potential runtime errors. This change aids in maintaining robust interactions with the ROS2 service framework.
* refactor: simplify parameter naming in RPC proxy function
Rename the `ctx_ref` parameter to `ctx` in the RPC function signature for cleaner and more concise code. This enhances readability and maintains consistency across the codebase.
* fix: restrict static array sizes in RosTestRpc service
Limit the size of static array fields to three elements each for better resource management and to prevent potential overflow issues.
* feat: enhance python runtime generation for ROS2 services
Add support for generating code from ROS2 service definitions, improving interoperability with the aimrt framework. Update build scripts to include new generation scripts and ensure file dependencies are configured correctly.
* refactor: update RPC service and client implementations to use ROS2 naming convention
Modify scripts to utilize the new aimrt_py-gen-ros2-rpc tool and update service and client references accordingly for consistency and clarity. Remove deprecated code to streamline functionality and improve maintainability.
* chore: update .gitignore to exclude generated files
Add pattern to ignore *_aimrt_rpc_ros2.py files to keep the repository clean from auto-generated files.
* refactor: streamline response structure for RosTestRpc
Remove unused fields from RosTestRpc response to simplify the data structure and enhance clarity. Adjust logging level for better control over output verbosity.
* chore: update log level to INFO for consistency
Adjust the core log level to INFO to ensure a more standard logging output and reduce unnecessary verbosity in the logs.
* docs: add README for ros2 rpc examples
Provide detailed instructions and explanations for setting up and running Python RPC examples using ros2 protocols with HTTP, gRPC, and native ros2 backends.
* feat: enhance aimrt_py channel with rpc support for ros2 message types
Add support for ros2 message types in both aimrt_py channel and rpc to improve compatibility and functionality.
* docs: add ros2_rpc example to Python interface section
Include a new example link to enhance the documentation and provide more resources for users exploring the Python interfaces.
* chore: add spacing for improved readability in service proxy class
Improve code readability by adding blank lines in the service proxy class definition.
* chore: standardize argument names for RPC generator
Update argument names in the RPC generation script and implementation for consistency, enhancing readability and usability.
* docs: update RPC documentation to include ROS2 Srv support
Add examples and instructions for using ROS2 Srv in RPC, enhancing integration options for developers. Adjust existing protobuf references for clarity and consistency.
* style: standardize whitespace in RosTestRpc.srv
Improve readability by ensuring consistent spacing in the service definition.
* build: exclude ROS2 specific files from the build if not using ROS2
Remove ROS2-related source files from the compilation when the project is configured without ROS2 support, helping to streamline the build process and avoid unnecessary dependencies.
* style: add missing newline at end of file for consistency
* refactor: rename copy function to improve clarity
Refactor the function used for copying messages within dynamic arrays to better convey its functionality. This change enhances code readability and maintainability.
---------
Co-authored-by: zhangyi <zhangyi@agibot.com>
Include a method to print detailed startup information about the framework, enhancing user awareness of the version and providing relevant links for support.
* feat(opentelemetry_plugin): Add RPC tracing and performance metrics
- Added multiple counters and histograms in OpenTelemetryPlugin for tracking RPC calls
- Updated ChannelTraceFilter and RpcTraceFilter with enhanced context attribute handling
- Added new RpcMetricsFilter for collecting RPC performance metrics
- Adjusted log level configuration from INFO to Warn
- Added link to echo_plugin example in documentation
* fix: format the code
* fix : format
* perf(opentelemetry_plugin): Optimize RPC performance metrics calculation logic
* fix: Simplify opentelemetry plugin code
* refactor(opentelemetry_plugin): remove rpc status
* fix: delete unnessary label
* format
* feat(opentelemetry_plugin): Add custom histogram boundaries option for RPC metrics
* fix(opentelemetry): Fix histogram boundary value type
* fix: change new to make_unique
* docs: add opentelemetry_plugin doc
* fix: opt the expression of doc
* choro: format the code
* docs: opt opentelemetry doc
* fix: update OpenTelemetry plugin documentation
- Change trace_otlp_http_exporter_url and metrics_otlp_http_exporter_url fields from required to optional
- Optimize capture list in OpenTelemetryPlugin::RpcMetricsFilter function
* add zenoh-shm API
* use zenoh shm-api for channel and rpc
* set z_alloc_result as a local variable.
* add zenoh_buffer_array_allocator
* avoid copy opreation when pub data with shm
* if shm pool size is not enough, use net buffer instead
* add z_pub_shm_size_map_ to store topic-loan_size
* little fix
* remove client send data 's copying
* remove server send data 's copy
* add doc
* change benchamrk item
* minor modification
---------
Co-authored-by: hanjun <hanjun@agibot.com>
Improve error handling for async wait operations in both RPC backends by catching system errors, ensuring robustness against unexpected cancellations. This change addresses potential crashes and enhances stability during RPC service registration.
* Optimize reconnection steps.
* Using condition variables to establish a connection with the broker.
* use aimrt's light_signal
* add condition variable for channel and rpc
* Change the notify timing to the start phase
* Remove redundancy
* Modify the timing of the sleep call
---------
Co-authored-by: hanjun <hanjun@agibot.com>
Configure the build system to include the source directory in the proto path for all relevant targets, ensuring improved resolution of proto files during code generation.
* build: enhance build options for modular components
Add dependent options for building various plugins and components, allowing finer control over runtime and external library usage. This change improves flexibility and ensures that components are only built when their dependencies are active, optimizing the build process.
* build: update grpc plugin dependency condition
Remove protobuf dependency requirement for the grpc plugin, simplifying its build configuration. This improves flexibility by allowing the grpc plugin to be built independently of the protobuf option.
---------
Co-authored-by: zhangyi <zhangyi@agibot.com>
* feat: Asynchronous connection to mqtt broker
* add new option: client_key_password
* add example for mqtt plugin with ssl/tls
* add new info at release notes
* Make minor formatting adjustments.
* Improve mqtt_plugin's README documentation
---------
Co-authored-by: hanjun <hanjun@agibot.com>
* feat: add functionality to convert multiple aimrt bags into a single ROS bag
* refactor(rosbag_trans): add DatabaseManager class to unify database operations
* fix: format the code
* fix: format code
* feat(bagtrans_tool): Update Command Line Tool Documentation
* build: add error handling for local protoc compiler detection
Ensure that the local `protoc` compiler is found when `AIMRT_USE_LOCAL_PROTOC_COMPILER` is enabled. This improves setup reliability by providing clear feedback if `protoc` is missing, helping users avoid runtime issues.
* build: include YamlCpp for enhanced configuration support
Add support for YamlCpp to improve configuration handling alongside ROS2 dependencies.
* chore: remove redundant gflag setting
Clean up the CMake configuration by removing the unnecessary gflag setting for testing, streamlining the build process.
* build: refactor CMake scripts to use functions for variable scope
Wrap multiple CMake scripts in functions to restrict variable scope and prevent unintended resets. This ensures better modularity and maintainability in the build process while adhering to modern CMake best practices.
* refactor: simplify opentelemetry fetch logic
Streamline the handling of OpenTelemetry dependencies by removing unnecessary function wrappers and directly implementing the fetching logic. This improves readability and maintainability while ensuring that relevant variables are correctly set within the proper scope.
* refactor: encapsulate OpenTelemetry configuration in a function
Wrap the OpenTelemetry setup in a function to limit variable scope, improving code organization and maintainability.
* feat: add timer module integration
Integrate the new timer module into the executor package, enhancing functionality and providing more precise timing capabilities within the system.
* feat: add timer class for periodic task scheduling
Implement a Timer class that enables users to schedule recurring tasks with configurable periods. This enhances the executor functionality by allowing more precise timing control and task management within the AimRT framework.
* refactor: replace WallTimer with aimrt::executor::Timer and enhance logging
Streamline the timer module by removing the custom WallTimer implementation in favor of the built-in aimrt::executor::Timer. Improve logging to track execution intervals, providing clearer insights into task execution frequency.
* feat: enhance timer functionality and behavior
Introduce a shortened sleep duration for task execution and add cancellation capability for timers, improving responsiveness and efficiency in managing timer events.
* feat: enhance timer functionality with flexible period handling
Refine the timer by allowing a customizable reset period, improving task scheduling accuracy, and ensuring that callbacks execute only when appropriate. This update addresses potential timing issues when the timer is reset, enhancing overall reliability in task execution.
* feat: improve timer module functionality and simplify timer creation
Enhance the timer module by updating the logging to microseconds, refactoring timer creation for improved clarity, and adjusting timing intervals for better performance and maintainability.
* feat: add utility for comparing function argument types
Introduce a new utility to compare argument types of functions, enhancing type safety and flexibility in the Timer implementation. Update Timer module to integrate this utility for improved argument type checks. Additionally, adjust timer intervals for more appropriate timing behavior.
* test: add comprehensive tests for SameArguments trait functionality
Introduce a series of tests to validate the behavior of the SameArguments trait across various function types, member functions, function objects, lambda functions, and complex argument types. This ensures compatibility and correctness in argument matching, enhancing type safety and reliability in code usage.
* style: format function definitions for clarity
Improve the readability of the TimerBase class by formatting function definitions to align with standard coding style.
Expand timer functionality to support const reference callbacks, enhancing flexibility in task management.
* style: ensure newline at end of file and tidy up CMakeLists.txt
Update formatting for consistency and readability by adding a newline at the end of the file and improving the organization of the CMakeLists.txt.
* chore: update include paths for consistency
Refactor the include statement for the same_arg_trait to follow the new directory structure, promoting better organization and maintainability.
* fix: clarify comment on task execution timing
Ensure that the executor guarantees all tasks are executed after their planned time to handle timer resets more effectively.
* refactor: simplify cancellation check in timer execution
Improve code clarity by replacing direct access of a member variable with a method call for cancellation checks. This enhances maintainability and encapsulates the cancellation logic.
* refactor: enhance timer interface to support configurable period
Revise the TimerBase and Timer classes to allow starting and resetting with a specific duration. This improves flexibility, prevents duplicate callbacks on resets, and ensures more accurate callback scheduling.
* feat: improve timer functionality and logging
Enhance the timer with more precise intervals and additional logging for better tracking of execution and reset events. Adjust execution periods for improved timing accuracy and introduce dynamic start behavior for better flow control.
* refactor: adjust timer periods for improved performance
Update timer initialization and execution intervals to enhance timing accuracy and operational efficiency.
* refactor: rename callback method for clarity
Update the timer interface to use "ExecuteTask" instead of "ExecuteCallback" for improved readability and accuracy in describing the method's purpose. Ensure that task cancellation is properly handled when auto-start is disabled.
* docs: enhance timer documentation and add usage examples
Clarify the timer interface and its functionality, including creation, scheduling, and task execution. Provide practical usage examples to improve understanding and facilitate integration into projects.
* chore: update copyright information to reflect current year and new authors
Ensure compliance with licensing requirements by revising the copyright and license details in the CMake configuration.
* fix: address potential duplicate callback executions on timer reset
Remove commented FIXME notes regarding edge case of duplicate callbacks when the timer is reset to the same time point.
* fix: adjust timer intervals for improved timing accuracy
Reduce timer intervals from seconds to milliseconds to enhance responsiveness of the timer functionality. Implement a sleep in the shutdown process to ensure all timer executor tasks complete properly before shutdown.
* refactor: simplify timer restart logic
Consolidate timer actions by removing redundant cancellation and restart statements. Adjust logging to reflect the accurate restart timing, enhancing clarity and reducing unnecessary latency.
* fix: add cancellation check in timer execution loop
Ensure that the timer's execution loop properly checks for cancellation, optimizing performance and preventing unnecessary operations when the timer is no longer needed.
* refactor: update time point calculations for accuracy
Improve the handling of time point arithmetic in the Timer class to ensure precision during execution and scheduling. This revision clarifies the time calculations, preventing potential errors in scheduling tasks.
* feat: add synchronization support to Timer class
Implement SyncWait method to allow for synchronous waiting on timer tasks, enhancing task execution control and reliability.
* refactor: streamline timer execution logging
Improve timer execution logging by incrementing the execution count directly within the log statement. Ensure the timer synchronously waits during shutdown to enhance reliability.
* feat: add SyncWait method to TimerBase for safer resource cleanup
Improve timer behavior by introducing SyncWait to ensure resources are correctly released after cancellation before the next execution point. Update timer intervals for enhanced responsiveness and logging clarity.
* feat: add timer based on executor for scheduled tasks
Introduce a new feature to facilitate scheduled task execution with an executor-based timer, enhancing the flexibility and usability of the task management capabilities.
* refactor: streamline timer initialization and assertion handling
Remove inline assertions from the TimerBase constructor and relocate assertions to the CreateTimer function, enhancing clarity and maintaining execution flow. This simplifies timer initialization while ensuring that critical checks occur before timer creation.
* refactor: simplify timer task management and logging
Improve timer initialization and task execution by streamlining start and reset processes. Enhance logging clarity by aligning messages with timepoints and ensuring the timer cancels correctly after reaching execution limits.
* docs: simplify TimerBase interface documentation
Clarify method descriptions and refine behavior explanation to enhance understanding of TimerBase functionality, particularly around the Reset and Start methods.
* refactor: optimize task forwarding in Timer constructor
Improve task handling by using std::forward to perfect-forward the task parameter, ensuring efficient movement semantics and reducing potential overhead.
---------
Co-authored-by: zhangyi <zhangyi@agibot.com>
* feat: enhance gRPC content-type handling and serialization support
Improve content-type validation in gRPC request headers to support additional types, allowing for JSON serialization. Update the serialization logic to dynamically set the type based on incoming headers, ensuring better compatibility and error handling.
* feat: support ros2 service function names
Enhance service function registration to accept names starting with 'ros2:' in addition to 'pb:'. Update URL path handling and content type mappings accordingly to ensure compatibility with ROS 2 services, improving integration capabilities.
* feat: add gRPC plugin configuration and startup scripts
Introduce configuration files for the gRPC client and server plugins, allowing for easier setup and management of RPC communication. Add shell scripts to launch the client and server with the specified configurations, streamlining the development process.
* refactor: improve service function name validation and error handling
Enhance the clarity of service function name registration by separating the function name variable for improved readability. Update error messages for better guidance on valid prefixes and standardize maps for content types and serialization types. This increases maintainability and reduces the risk of errors during registration.
* refactor: streamline client option lookup and improve code clarity
Simplify the client option lookup by replacing `std::find_if` with `std::ranges::find_if`. Also, enhance readability by cleaning up comment formatting and unnecessary whitespace.
* chore: update copyright information in configuration files
Revise copyright year and licensing details to reflect the current ownership and license for the AimRT project.
* refactor: improve validation logic in options
Enhance option verification by using standard algorithms for consistency and readability. This ensures minimum thresholds for connection numbers and timer durations are respected, improving robustness in client and server configurations.
* docs: update release notes and plugin documentation
Add support for grpc plugin serialization with ros2 messages and json format, enhancing flexibility in data handling. Remove outdated protobuf-only restriction to improve compatibility and user experience.
* docs: add ros2 rpc example details and usage instructions
Expand the README to include a new section on using the grpc plugin with a ros2-based RPC interface. Provide explicit instructions on configuration, core code references, and running the server and client. Enhance the documentation to clarify the differences from the protobuf RPC example.
---------
Co-authored-by: zhangyi <zhangyi@agibot.com>
* refactor(echo_plugin): Remove executor configuration and simplify echo logic
- Removed executor field from echo_plugin configuration
- Simplified echo message handling process by processing directly in main thread
- Updated example configurations and descriptions in documentation
* refactor(echo_plugin): Refactor EchoPlugin class
- Remove get_type_support_func_ member variable, replace with direct GetTypeSupport method call in RegisterEchoChannel
- Merge EchoFunc creation and subscription callback logic to reduce intermediate variables
* refactor(echo_plugin): Remove GetTypeSupport function, directly access type_support_map where needed
* refactor(echo_plugin): Remove unused headers and member functions
* refactor(echo_plugin): Remove unnecessary 'this' capture in lambda expression
* refactor(echo_plugin): optimize buffer handling logic in EchoPlugin
* format
* fix(echo_plugin): add release_callback func before return in sub_wrapper.callback
---------
Co-authored-by: yuguanlin <yuguanlin@agibot.com>
* CI: change build worlflow image tag from v20240927 to latest
* refactor(tools): Restructure bagtrans tool and integrate into aimrt_cli
- Integrate bagtrans functionality into aimrt_cli
- Update CMakeLists.txt and documentation to reflect these changes
* choro: format the code
* choro: change the document
* choro: remove the bagtrans options
---------
Co-authored-by: yuguanlin <yuguanlin@agibot.com>
* CI: change build worlflow image tag from v20240927 to latest
* feat/plugins: Add echo plugin
- Add echo plugin for message pass-through and logging
- Implement loading and management of different types of support packages
- Add support for multi-threaded executors
- Optimize log initialization and management logic
- Add support for YAML configuration files
* build: Update build scripts and enable Echo plugin
- Add build options for Echo plugin in build.bat, build.sh, test.bat, and test.sh scripts
- Optimize JSON serialization error handling and log output in echo_plugin.cc
* chore: Add Echo plugin related documentation
- Update release notes with Echo plugin feature description
- Add Echo plugin usage documentation
- Add Echo plugin example configuration and running instructions
* chore: format the code
- Add thread safety checks for Echo executor
- Optimize code structure to improve readability and maintainability
* choro: restructure JSON parsing logic
- Replace json-c with jsoncpp library
- Rewrite json_to_yaml function to improve code readability and robustness
* choro: adapt CMakeLists for Windows compatibility
* choro : turn off the echo plugin in windows
* feat(echo_plugin): Support YAML format message echo
- Modify GetYamlCpp.cmake to enable yaml-cpp installation
- Add yaml_convert.h and yaml_convert_test.cc in ros2_util
- Update echo_plugin to support YAML format message serialization and deserialization
- Add YAML serialization type support in aimrt_module_ros2_interface
* choro: Fix documentation
* choro : fix format and delete the extra support for echo about pb message type
* choro : format
* choro: add ros2 example for echo plugin and delete useless code
* choro: rename the echo example shell
* choro: fix some mistake
* chore: refactor type support package loader and migrate to core module
- Migrate TypeSupportPkgLoader from echo_plugin and record_playback_plugin to core/util directory
- Optimize log output, replace printf with AIMRT_INFO
* choro: replace the aimrt::common::util::AimRTException() to AIMRT_ASSERT
---------
Co-authored-by: yuguanlin <yuguanlin@agibot.com>
Remove outdated note about file generation failure due to missing package name in proto files to enhance clarity and usability for developers.
Co-authored-by: zhangyi <zhangyi@agibot.com>
* CI: change build worlflow image tag from v20240927 to latest
* ci: Optimize GitHub Actions workflow triggers and test execution
- Ignore changes in the .github and document directories to avoid unnecessary workflow triggers
- Add 'quick-ci' label to control test execution and improve CI efficiency
* choro: add quick ci mode
---------
Co-authored-by: yuguanlin <yuguanlin@agibot.com>
Enhance the generation of message type names by ensuring proper handling of package and message components, eliminating excess separators for cleaner output.
* Refactor coroutine request handling and ensure unique client keys
* Refactor client_key to use ClientKey struct with custom hash to ensure uniqueness and support IPv6
* docs: clarify context type enumeration description
Enhance the explanation of the `aimrt_channel_context_type_t` enumeration to clearly indicate its role in defining publisher and subscriber contexts. This improves understanding for users implementing the interface.
* feat: enhance RpcContext with additional features
Add new methods for managing context metadata, timeout settings, and target addresses. Improve logging to provide better visibility into RPC calls and responses, aiding in debugging and performance monitoring.
* feat: enhance RPC context logging with metadata
Add the ability to log metadata in RPC calls, improving traceability and debugging. Update the client to set a metadata value and enhance server logging to print out all metadata associated with requests.
* feat: add RPC context types to Python bindings
Introduce enum values for client and server RPC context types in Python bindings to enhance type support and improve clarity in interactions with RPC features.
* feat: set default serialization type for context reference
Ensure that the serialization type defaults to "pb" when it is not explicitly set in the context reference. This improves compatibility and prevents potential errors related to serialization handling.
* docs: enhance message publishing and context usage documentation
Clarify the usage of the `Publish` function by adding context and serialization options. Introduce `Context` and `ContextRef` details for improved understanding. Adjust subscriber callback signatures and remove deprecated notes for a cleaner documentation experience.
* feat: enhance event publishing with context and serialization options
Add support for publishing events with various configurations, including without context, with JSON serialization, and with context references. Improve logging for better debugging and clarity in event handling.
* feat: add enumeration for channel context types
Introduce enumeration for `aimrt_channel_context_type_t` to better categorize channel contexts, improving readability and usability in Python bindings.
* docs: clarify context type description
Enhance documentation by simplifying the explanation of the context type and explicitly defining the associated enumeration values for better understanding.
* refactor: standardize timestamp handling with time.time_ns()
Update timestamp handling in both publishing and subscribing modules to use time.time_ns() instead of time.perf_counter_ns(). This change improves consistency in timestamp precision and ensures uniformity across the system's message timing functionalities.
* perf: improve timing measurements with nanosecond precision
Enhance performance tracking by switching from `time.time()` to `time.perf_counter_ns()`, providing more accurate duration calculations.
* fix: ensure subscriber receives all messages before ending
Add a short sleep to guarantee the subscriber has enough time to process all published messages before signaling completion. This prevents potential missed messages during the benchmarking process.
* perf: optimize timestamp retrieval for benchmarking
Use high-resolution `perf_counter_ns` instead of `time.time` for better accuracy in message timestamps across publisher, subscriber, and RPC client modules.
* refactor: remove shutdown peer logic from publisher and subscriber
Streamline benchmarking process by eliminating shutdown peer signal handling, simplifying the code and improving clarity.
* docs: clarify benchmark termination process
Update the README to specify that benchmark results will be output in the subscriber terminal and that the process can be terminated in both terminals using `Ctrl+C`. This improves user guidance for smoother execution.
* CI: change build worlflow image tag from v20240927 to latest
* fix: fix bagtrans tool support
- Add AIMRT_BUILD_BAGTRANS option in CMakeLists.txt
- Update build.bat, build.sh, test.bat and test.sh scripts to include bagtrans build option
- Modify CMakeLists.txt in bagtrans directory to simplify build logic
- Remove autopep8 dependency from bagtrans/requirements.txt
* format : format the code
* fix: Turn off the bagtrans compilation option on Windows
* feat(tools): Update bagtrans tool build method
- Change the build method of bagtrans tool from PyInstaller to using the build module to generate wheel files
- Update CMakeLists.txt and setup.py files to adapt to the new build method
- Update release notes, adding new information about the bagtrans tool
* fix: format
---------
Co-authored-by: yuguanlin <yuguanlin@agibot.com>
* add remapping function for ros2 plugin
* Optimize the logical structure of remapping.
* Optimize the remapping's logic
* Simplify details
* - update the ROS2 plugin documentation to correct the description of the remapping rules and optimize examples;
- enhance the Ros2RpcBackend class by adding exception handling logic to the GetRemappedFuncName method;
- add a function initialization report feature;
- write unit test cases for GetRemappedFuncName covering various scenarios.
* Update the table format in the documentation, correcting the regular expression capturing groups for function names
* Decrease Redundancy
* simplify the function : GetRealRosFuncName
* Optimized the way of obtaining the message type, reducing unnecessary string constructions.
---------
Co-authored-by: hanjun <hanjun@agibot.com>
* feat: add new methods to RpcContext and RpcContextRef
Enhance functionality by introducing CheckUsed, SetUsed, Reset, GetFunctionName, and SetFunctionName methods for better state management and function identification.
* feat: add RPC service details to ServiceBase class
Enhance the ServiceBase class by adding methods to retrieve RPC type and service name, along with the ability to set the service name. This improves accessibility and flexibility for RPC configurations.
* feat: simplify service function type definition
Introduce type aliases for service function return and parameter types to enhance code readability and maintainability. This change reduces redundancy and clarifies the expected function signatures, streamlining future development.
* feat: enhance RPC framework with proxy support
Add support for `ProxyBase` in the RPC framework, enabling more flexible service management and context handling in Python. Update the `RpcContext` definition to use shared pointers for better memory management.
* feat: enhance rpc context handling and method overloads
Improve the handling of RPC context by adding overloads for method arguments, ensuring type safety and clarity in usage. This change simplifies the implementation of service proxies and makes it easier to work with different context types.
* feat: enhance context handling in RPC proxy
Add default context reference to the `NewContextSharedPtr` method, simplifying context management in RPC calls for improved usability.
* chore: reorganize imports for consistency
Refactor the import statements across multiple modules to improve readability and maintain consistency. Ensure all relevant libraries are imported in a coherent manner.
* feat: add GetTopic method to PublisherRef and SubscriberRef
Expose the GetTopic method for both PublisherRef and SubscriberRef to improve topic management and enhance usability within the Python interface.
* feat: add context handling in publishing
Introduce new context management methods for publishing messages with context support. Enhance the Python bindings to allow for better integration with context references, improving the flexibility and usability of the publisher functionality.
* feat: enhance subscription with context support
Add a new subscription method that includes context handling for better message processing. This improves the flexibility of message serialization formats and error handling during callback execution.
* refactor: clean up publish and subscribe methods
Improve code readability by removing unnecessary blank lines and ensuring consistent formatting in the publish and subscribe functions.
* style: update ASCII art formatting in example runner
Improve visual consistency of the ASCII banner in the output, enhancing readability.
* chore: improve type annotations for publisher and subscriber functions
Enhance the type hints in the RegisterPublishType, Publish, and Subscribe functions to improve code clarity and maintainability. This facilitates better integration with type-checking tools and helps prevent potential runtime errors.
* feat: support multiple serialization types in publisher
Enhance the publishing functionality to handle both protobuf and JSON serialization types. This improves flexibility and allows for broader compatibility with different data formats. Add error handling for invalid serialization types to ensure robustness.
* fix: correct serialization type prefix
Update the serialization type from "pb" to "json" when publishing JSON messages, ensuring accurate format differentiation for better clarity and preventing potential processing errors.
* refactor: streamline serialization handling in PublishWithCtx
Improve message serialization by consolidating logic and enhancing readability. Ensure error handling for unsupported types remains clear.
* feat: add Context support for aimrt_py channel functionality
Enhance channel functionality in aimrt_py by providing Context support, improving usability and enabling better resource management during operations.
* refactor: streamline serialization type handling
Improve clarity by formatting the serialization type in the publish method. This enhances readability and ensures consistent output in message formatting.
* refactor: rename publish function and improve argument handling
Enhance the Publish function to accept different argument configurations and simplify the serialization process, ensuring clearer logic and improved usability.
* feat: enhance publishing with customizable serialization
Allow publishers to specify serialization type (protobuf or JSON) when publishing messages. Update method signatures to improve clarity and error handling for serialization type validation.
* feat: enhance Publish function documentation
Clarify usage and expectations for the Publish function, including argument types and potential exceptions. This improves maintainability and usability for future developers.
* refactor: simplify protobuf serialization handling
Streamline the protobuf message serialization and deserialization processes by separating concerns into dedicated functions. Improve callback handling for subscriber methods to enhance code readability and maintainability.
* refactor: streamline serialization and deserialization methods
Simplify the process of message serialization and deserialization by consolidating functions and improving code clarity. This enhances maintainability and reduces redundancy in handling protobuf messages.
* refactor: remove unused subscription method
Eliminate the `PySubscribeWithSerializationType` function to streamline the code and improve maintainability, as it is not being used in the current implementation.
* refactor: streamline callback parameter handling
Simplify the validation and handling of callback parameters in the subscription process. Ensure the callback adheres to a clear signature expectation, enhancing code maintainability and reducing potential errors.
* chore: streamline imports for clarity
Optimize import statements by specifying only required components, improving readability and maintainability.
* feat: enhance protobuf registration and subscription documentation
Improve docstrings for registering and subscribing to protobuf message types, clarifying parameter details and callback expectations to aid developer understanding and usage.
Set CMAKE_POSITION_INDEPENDENT_CODE to ON to ensure compatibility with shared libraries and enhance portability across different architectures. Removed explicit compiler flags for PIC that were previously set.
