Introduces a `parent_organ_id` field to the `LedPump` struct and updates its constructor. This establishes a clear hierarchical link, allowing a `LedPump` instance to identify its containing organ.
Additionally, changes the `last_beat` field type from `u128` to `u64` for optimized storage of beat tracking data.
Introduces a `Parenchyma` trait to represent essential functional tissues within an organ, enabling a component-based architecture.
Transforms the `Heart` into a generic `Organ` capable of hosting multiple `Parenchyma` components, centralizing command processing. Adds a new `LedPump` parenchyma as an example component.
Includes an `impl_identifiable!` macro for streamlined implementation of the `Parenchyma` trait and establishes an ID generation system for organs and their components. Renames `OrganCommand::Beat` to `OrganCommand::HeartBeat` for improved clarity.
Ensures the brain only processes commands from organs that return an 'Ok' response.
Specifically, the 'Waken' command now requires an 'Ok' response to transition the brain to the 'Awake' state, improving the robustness of inter-organ communication.
Removes unnecessary line breaks and comments, improving code readability and consistency.
Consolidates multi-line function signatures and variable declarations into single lines.
Introduces a `last_reported_state` field to `OrganSocket` for better management of each organ's lifecycle status.
Updates `OrganSocket` and `Heart` constructors to accept an initial `LifeState`, allowing for more flexible initialization. The `OrganFactory` is adjusted to pass this state during organ creation.
This change provides a centralized mechanism for monitoring the state of all spawned organs.
Includes a unique identifier for the sending organ in `BrainMessage`.
Enables the Brain to differentiate and respond appropriately to messages from various organs.
Refactors `Brain` method for clearer communication flow.
The Brain now broadcasts a 'Waken' command to all connected organs during its startup phase. Organs, like the Heart, transition to an 'Awake' state upon receiving this command and provide feedback. The Brain then updates its own 'LifeState' to 'Awake' once organs acknowledge the wake-up.
This change establishes a fundamental handshake, ensuring that core system functions only activate once the components are initialized and responsive. It introduces the `LifeState::Awake` and `OrganCommand::Waken` states for this purpose.
Removes several `LifeState` variants, focusing on a more essential set of states for the core system.
Eliminates various `OrganCommand` protocols that are no longer needed, reducing the overall complexity of inter-organ communication.
Adjusts the `Brain`'s main loop to actively process organ messages, simplifying its core operational logic.
The Brain now actively rests when in the `Dead` lifecycle state, ensuring consistent idle behavior and continuous logging of its status.
Adds the `Display` trait implementation for `LifeState`, providing human-readable representations of lifecycle states for improved debugging output.
Introduces a dedicated `system::time` module to provide consistent millisecond timestamps throughout the application.
Refactors the `Heart` organ to process `Beat` commands, incorporating a cooldown mechanism to regulate its rhythm.
Updates the `Brain` to periodically request a heartbeat from its organs when in an active lifecycle state, utilizing the new time utilities. Ensures organs are initialized before the brain begins its operational loop.
Activates the Heart organ's main command processing loop by calling its `start` method.
Replaces the previous placeholder `run_loop` method with the functional `start` method. The `start` method now takes a mutable reference to `self`, which enables it to operate as a long-running process without consuming the `Heart` instance.
Introduces `OrganFactory` to manage the creation and spawning of organs, running each in its own thread. `OrganSocket` provides the Brain's interface for sending timestamped commands to specific organs.
Configures new MPSC channels within the Brain to handle bidirectional communication with its organs, enabling command dispatch and feedback reception. The Heart is integrated as the first example organ within this architecture.
Establishes the core `organs` module, including a basic `Heart` implementation, to structure internal components.
Introduces a `protocols` layer to define message passing and communication between the `Brain` and various `organs`.
Adds a `coordinates` module with a `Point3D` struct for spatial definitions.
Increases the `Brain`'s resting sleep duration for minor tuning.
The `State` enum, along with its variants (Starting, Running, Stopping, Stopped), is no longer required for managing the brain's operational stages. This change simplifies the codebase by removing an unnecessary abstraction.
Refactors the application shutdown mechanism to use lifecycle commands.
OS signals (SIGTERM/SIGINT) now sends a `Dying` command directly to the brain.
The brain processes this command, transitioning through `Dying` to `Buried` state.
The main loop now explicitly waits for the brain to report a `Dead` or `Buried` state before exiting, ensuring a graceful shutdown.
Increases the brain's rest duration and adds debug logging.
Replaces simple string messages sent from the Brain with a structured `LifecycleReceipt` object.
This receipt provides comprehensive feedback, including the original command, a specific response status (e.g., `Ok`, `Refused`), and the resulting `LifeState`. This change improves the clarity, type safety, and debuggability of inter-thread communication between the main God thread and the Brain.
Extracts core application setup, brain management, and OS signal handling into dedicated functions.
Improves readability and modularity of the main execution flow.
Removes an unused variable and updates the build number.
Introduces a multi-threaded architecture where the brain operates in its own thread.
Establishes explicit MPSC channels for communication, enabling the main application (God) to send `LifecycleCommand` messages to the brain and receive status updates. This replaces the previous polling-based `update` loop with an event-driven model.
Defines a comprehensive `LifeState` enum for more granular and robust state management. The `LedPump` component is removed as its functionality is superseded by the new command-driven state transitions.
This architectural shift improves separation of concerns and lays the groundwork for more complex and responsive robot control.
Introduces an `increment` Cargo feature to control the automatic incrementing of the build number during the build process.
This change prevents the build number from incrementing on every build, providing more control for local development and specific release scenarios. The build number will now only increment when the `increment` feature is explicitly enabled.
Adds `cargo:rerun-if-changed=src/` to ensure the build script re-runs when source files change.
Introduces a build script to automatically increment a build number with each compilation.
This number is combined with the semantic version to create a full version string.
The full version is then exposed to the application and logged at startup, providing a unique identifier for each build to aid in tracking and debugging.
Adds a `LedPump` component to the `Brain` to execute logic periodically while in the `Running` state.
This establishes a basic timing mechanism that currently logs debug messages at a fixed interval, providing a foundation for future timed operations or state transitions. The default logging level is adjusted to `debug` to ensure these periodic events are visible.
Renames the `mod.rs` file for the `brain` module to `brain.rs`.
This simplifies the module path and aligns with standard Rust practices for modules defined entirely within a single file.
Replaces existing `println!` statements with `tracing::info!` macros for improved observability and debuggability.
Configures `tracing-subscriber` to enable structured logging, allowing for flexible filtering via `RUST_LOG` and compact, human-readable output by default.
Refactors the existing `RobotNode` module by renaming its directory and associated files to `Dixon`. This consolidates the core C++ robot node under a new name.
Introduces the initial `rustylee` module, establishing a foundational structure for the robot's brain. This new Rust component includes:
- A state machine (Starting, Running, Stopping, Stopped) to manage the brain's operational lifecycle.
- Graceful shutdown capabilities using a `ctrlc` signal handler.
- A main watchdog loop that orchestrates state transitions and responds to shutdown requests.
Introduces the `rustylee` Rust project with a basic "Hello, world!" application.
Configures cross-compilation for `aarch64-unknown-linux-gnu` targets using `cargo.toml`.
Adds a deployment script to automate pushing the compiled ARM64 binary to a remote host.
This enables development and deployment of Rust applications for the target environment.
Moves GPIO pin and chip definitions to a central
constants file for easier management and consistency.
Refactors the heart component to utilize these centralized
constants, enhancing code maintainability and readability.
Refactors the location of the heart module for better organization and clarity.
Updates the include paths and CMakeLists.txt to reflect the new location.
Increments the version number.
Updates source file names to adhere to a consistent lowercase convention, improving code maintainability and readability.
This change ensures consistency across the codebase and aligns with common coding standards.
Updates the version logging to use the DIXON_VERSION macro.
This allows the version to be dynamically injected at compile time, instead of a hardcoded string.
Adds logging to heart component and signal handler for improved debugging.
Changes signal handler to set a "StopPending" state to allow the main loop to handle shutdown.
Fixes a potential thread join issue during shutdown.
Adds a basic logging system using std::clog with color codes for different log levels.
Refactors the main loop to use the logging system and improve readability.
Changes DixonNodeState to use atomic exchange for setting node status and logs status changes.
Removes the old main.cpp and adds a new one that uses a separate thread for signal handling.
Updates the CMakeLists.txt to link against gpiod and spdlog.
Moves version information into a version.txt file and creates a custom target to bump the version using a python script.
Simplifies the RobotNode build process by linking directly to system gpiod libraries instead of including a local copy. This reduces redundancy and ensures compatibility with the system's gpiod installation.
Adds a deployment script for easier deployment to the robot, streamlining the update process.
Also introduces a script to automatically fix symlinks during cross-compilation, ensuring that links resolve correctly on the target system.
Adds signal handling for graceful shutdown via SIGINT and SIGTERM.
Updates the control loop to be interruptible, allowing for a clean exit when a shutdown signal is received.
Changes the node state management to use an enum for clarity and better control the run states (starting, running, stopping, stopped).
The heartbeat is stopped when the node is stopping or stopped.
Also updates the line request to force an inactive state when claiming the pin.
Also updates the version number.
Replaces mutex with atomic booleans in DixonNodeState for improved thread safety. This eliminates the need for explicit locking in the connected_ and brainRunning_ accessors, reducing overhead and potential for deadlocks.
Updates version file.
Renames the executable to lowercase and updates the corresponding dependency links in CMakeLists.txt.
Introduces a version file to manage the project's version.
Implements an automatic versioning system for the robot node,
utilizing a `version.txt` file and a Python script to increment
the patch version.
Integrates the version into the CMake build process to ensure
the version is displayed in the robot node's output.
Introduces a heartbeat mechanism to the robot node using GPIO.
This allows for external monitoring of the node's active state.
The heartbeat is implemented using a GPIO pin that toggles
at a regular interval, indicating that the system is running.
Updates CMakeLists to link the project with gpiod libraries
staged locally.
Adds .gitignore entries for local dependencies and PC build directories.
Updates the heart beat mechanism to use a prepared request to control the GPIO line, improving efficiency and code clarity.
Removes the direct line request in the beat function.
Switches to using pkg-config to manage dependencies and linker flags.
Sets up the initial project structure for the Dixon robot,
including core components and build configurations.
This commit lays the foundation for future development by:
- Adding necessary `.idea` files for IDE configuration,
including `.gitignore`, `aws.xml`, `modules.xml`, `vcs.xml`,
`editor.xml`, and `encodings.xml`
- Creating `Heart` component for managing heart beat with GPIO.
- Setting up CMakeLists.txt to define project dependencies and configurations,
including specifying C++20 standard and linking necessary libraries.
Introduces a basic structure for the robot control node. This includes:
- A central brain component that manages the robot's logic.
- A state management system using a singleton to ensure thread-safe access to shared data.
- A simple main loop that can be started and stopped.
- Initial CMakeLists.txt and gitignore configurations.
This provides a foundation for implementing robot control logic.
