fix(documentation): Rename ALL node mentions to TILMANN naming conventions

.gitignore

@@ -31,7 +31,6 @@ qtcreator-*
 
 # Colcon custom files
 COLCON_IGNORE
-!src/*/COLCON_IGNORE
 AMENT_IGNORE
 
 .vscode

doc/architecture/IMU/ESP32-IMU.md

@@ -1,77 +0,0 @@
-# IMU (MPU6886) ESP-IDF
-=====================
-
-Small ESP-IDF project that reads an MPU6886 IMU over I2C and publishes readings over MQTT.
-Includes an option to run WiFi in STA (client) or AP (access point) mode.
-
-### Features
-
-- I2C communication functions for MPU6886 (accelerometer, gyro, temp)
-- MQTT client using `esp-mqtt`
-- WiFi: STA or AP mode selectable at build time
-- AP mode defaults to static IP 192.168.10.1/24 (configurable in code)
-- MQTT, Serial toggle using the boot button on the esp32
-
-## Quick start
-
-### Prerequisites
-
-- ESP-IDF installed and activated (the repo was developed with ESP-IDF v5.x).
-- Toolchain and Python deps per ESP-IDF instructions.
-
-### Build and flash
-
-From the IMU root:
-
-```bash
-# configure project options
-idf.py menuconfig
-
-# build
-idf.py build
-
-# flash and monitor (set your serial port)
-idf.py -p /dev/ttyUSB0 flash monitor
-```
-
-## Project Configuration (menuconfig)
-
-Open `idf.py menuconfig` and there you will see the `ESP32 IMU Project Configuration` submenu where you can configure specific data for I2C, MQTT and WIFI
-
-### I2C
----
-In the `I2C Master configuration` submenu there are three options:
-- SCL GPIO Num  - Default 21 - GPIO used for I2C SDA
-- SDA GPIO Num  - Default 22 - GPIO used for I2C SCL
-- Master Frequency - Default 100000hz - I2C bus speed
-
-### MQTT
-
-- Broker URI - Default: `"mqtt://192.168.4.2:1883"`
-- MQTT Topic - Default: `"esp32/imu"`
-
-### WiFi / network
-
-- Toggle AP mode at build time by enabling `CONFIG_WIFI_AP_MODE` in menuconfig. If enabled the firmware will start as an access point on boot; if disabled the device starts as a station and attempts to connect to the configured SSID using the set Password
-- Toggle AP mode swaps the available settings when toggled between AP conf- and station configurations respectively
-- AP credentials can be set with `WiFi AP SSID` and `Wifi AP Password`.
-- Station credentials can be set with `WiFi SSID` and `WiFi Password`.
-
-### AP IP / DHCP
-
-- The AP is configured by default to use a static IP of `192.168.4.1` with netmask `255.255.255.0` and a DHCP server is started so clients receive addresses on that subnet.
-
-## Notes about units and macros
-
-- The macro `SF_RAD_S` (in `main/mpu6886.h`) is the degrees-to-radians conversion factor: PI/180. Gyroscope readings are converted from degrees/sec to radians/sec using this scale.
-- Sensitivity scale constants (e.g. `ACCEL_SO_2G`, `GYRO_SO_250DPS`) are used to convert raw sensor counts to physical units.
-
-## Troubleshooting
-
-- "`MQTT_TOPIC` undefined" at build time: run menuconfig
-- "I2C init failed": confirm SDA/SCL pins in menuconfig or wiring.
-
-## Files of interest
-
-- `main/mpu6886.c` - main application, WiFi init, MQTT publish loop
-- `main/mpu6886.h` - sensor constants and types

doc/architecture/architecture.md

@@ -1,14 +1,15 @@
-# ROS2 IMU Reader — Design Document
+# TI Minor Grade Generator Design Document
 
 ## Project Overview
 
-This projects reads data from a ESP32 communicating with serial or MQTT and writes this into a database for further processing
+Giving marks to students cost a lot of time and pain. For this a automatic solution is needed.
+Therefore the overall Software architect (Tilmann K.) has designed a solution for the ROS2 architecture.
 
 ## System Architecture
 
 ### High-Level Architecture
 
-The system consists of multiple ROS2 nodes that communicate through standardized topics and services to process imu data and store it in a database
+The system consists of multiple ROS2 nodes that communicate through standardized topics and services to process exam data, calculate grades, and persist results. The architecture ensures scalability, maintainability, and fault tolerance.
 
 ### Key Design Principles
 
@@ -19,37 +20,52 @@ The system consists of multiple ROS2 nodes that communicate through standardized
 
 ## System Components
 
-### ESP32-IMU
-*For ESP32 specific documentation see [ESP32-IMU.md](IMU/ESP32-IMU.md)*
-
 ### Core Nodes
 
-#### 1. IMU Databse writer Node
-**Namespace**: `assignments::two::imu_database_writer`
+#### 1. FinalGradeDeterminator Node
+**Namespace**: `assignments::one::g2_2025_final_grade_determinator_node`
 
-**Brief Description**: Recieves and stores IMU data.
+**Brief Description**: Collects exam results, triggers grade calculation when thresholds are met, and stores final grades.
 
-**Key Features**: Database persistence
+**Key Features**: Configurable collection thresholds, automatic grade calculation triggering, database persistence
 
-*For detailed documentation, see: [IMUDatabaseWriter.md](nodes/IMUDatabaseWriter.md)*
+*For detailed documentation, see: [FinalGradeDeterminator.md](nodes/FinalGradeDeterminator.md)*
 
-#### 2. LifeCycle Node
-**Namespace**: `assignments::two::lifecycle_manager`
+#### 2. GradeCalculator Node
+**Namespace**: `assignments::one::g2_2025_grade_calculator_node`
 
-**Brief Description**: Configures low level communication and manages the hardware interface to read on either serial or mqtt comunications.
+**Brief Description**: Provides grade calculation service with business logic including bonus points and grade validation.
 
-**Key Features**: Configuration of communications, device read activation and deactivation.
+**Key Features**: Average calculation, special student rules, grade bounds validation (10-100)
 
-*For detailed documentation, see: [LifecycleManager.md](nodes/LifecycleManager.md)*
+*For detailed documentation, see: [GradeCalculator.md](nodes/GradeCalculator.md)*
 
-#### 3. Hardware Interface
-**Namespace**: `assignments::two::hardware_interface`
+#### 3. ExamResultGenerator Node
+**Namespace**: `assignments::one::g2_2025_exam_result_generator_node`
 
-**Brief Description**: Manages low-level communication protocols (Serial/MQTT) for ESP32 data acquisition and forwards raw sensor data to processing nodes.
+**Brief Description**: Simulates exam result generation by maintaining a queue of student-course combinations and publishing random grades.
 
-**Key Features**: Multi-protocol communication support, connection management, raw data parsing and streaming.
+**Key Features**: Database-driven queue management, random grade generation, student enrollment handling
 
-*For detailed documentation, see: [HardwareInterface.md](nodes/HardwareInterface.md)*
+*For detailed documentation, see: [ExamResultGenerator.md](nodes/ExamResultGenerator.md)*
+
+#### 4. RetakeScheduler Node
+**Namespace**: `assignments::one::g2_2025_retake_scheduler_node`
+
+**Brief Description**: Manages retake exam scheduling and coordination for students who need to retake exams.
+
+**Key Features**: Retake request processing, schedule management, action server implementation for retake workflows
+
+*For detailed documentation, see: [RetakeScheduler.md](nodes/RetakeScheduler.md)*
+
+#### 5. RetakeGradeDeterminator Node
+**Namespace**: `assignments::one::g2_2025_retake_grade_determinator_node`
+
+**Brief Description**: Handles grade calculation and processing specifically for retake exams.
+
+**Key Features**: Retake-specific grade processing, integration with main grade system, retake result validation
+
+*For detailed documentation, see: [RetakeGradeDeterminator.md](nodes/RetakeGradeDeterminator.md)*
 
 ### Data Management
 
@@ -69,20 +85,42 @@ The system consists of multiple ROS2 nodes that communicate through standardized
 
 ### Communication Interfaces
 
-#### ROS2 Message Interface
-**Brief Description**: This project uses the ROS2 standard IMU sensor message
+#### ROS2 Message and Service Interfaces
+**Brief Description**: Custom message types and service definitions for inter-node communication.
+
+**Key Components**: Exam and Student message types, Grade calculation service, Retake action interface, standardized timestamps
+
+*For detailed documentation, see: [interfaces.md](interfaces/interfaces.md)*
 
 ## System Workflow
 
-### 1. Imu data  Processing
+### 1. Exam Result Processing
 
-1. **Input**: IMU data is sent from the ESP32 to the lifecycle node
-2. **Collection**: The lifcycle node recieves the data via a serial or MQTT connection
-4. **Data passthrough**: When data is recieved it is sent to the database writer
+1. **Input**: Exam results are published to the `exam_results` topic
+2. **Collection**: FinalGradeDeterminator receives and stores exam results by student-course combination
+3. **Monitoring**: System tracks the number of results per student-course pair
+4. **Threshold Check**: When `grade_collection_amount` results are collected, proceed to calculation
 
-### 2. Data Management
+### 2. Grade Calculation Process
 
-1. **Database Storage**: IMU data is persisted/stored in the database
+1. **Service Request**: FinalGradeDeterminator calls GradeCalculator service
+2. **Calculation**: GradeCalculator computes final grade using business logic
+3. **Validation**: Result is validated and clamped to acceptable range
+4. **Response**: Calculated grade is returned to FinalGradeDeterminator
+
+### 3. Result Management
+
+1. **Database Storage**: Final grade is persisted in the database
+2. **Publication**: Student information is published to management topic
+3. **Logging**: Process completion is logged for audit purposes
+
+### 4. Retake Processing Workflow
+
+1. **Retake Request**: RetakeScheduler receives retake requests via action interface
+2. **Schedule Management**: System schedules retake exams and manages timelines
+3. **Retake Execution**: Student completes retake exam, results are processed
+4. **Grade Processing**: RetakeGradeDeterminator calculates retake grades with specialized logic
+5. **Integration**: Retake results are integrated with main grade system and database
 
 ## Configuration Management
 

doc/architecture/classes/HardwareInterface.md

@@ -1,355 +0,0 @@
-# HardwareInterface (`assignments::two::g2_2025_lifecycle_node`)
-
-## Overview
-The `HardwareInterface` is a c++ class responsible for managing low-level hardware communication with ESP32-IMU combination via serial/MQTT and provides JSON parsing of sensor data, and publishes standardized `sensor_msgs::msg::Imu` messages to the database writer.
-
-#### Implementation Details
-
-**Public Methods**
-
-- **`start_read()`**: Spawns a background thread that continuously reads JSON payloads from the serial device
-- **`stop_read()`**: Signals the reader thread to exit and joins it for clean shutdown
-- **`write(const std::string& data)`**: Writes data to the serial device
-- **`open_device(const std::string& device_path, int baud_rate)`**: Opens and configures a serial port
-- **`is_device_open()`**: Checks if the serial device is currently open
-- **`close_device()`**: Closes the serial port and releases resources
-- **`mqtt_configure()`**: Initializes MQTT client and broker connection setup
-- **`mqtt_reader()`**: Attaches MQTT callbacks to begin receiving messages
-- **`mqtt_connect()`**: Establishes connection to the MQTT broker and subscribes to topics
-- **`close_mqtt_conn()`**: Disconnects from broker and cleans up MQTT resources
-- **`parse_data(const std::string& data)`**: Parses JSON payload into `sensor_msgs::msg::Imu` and publishes
-- **`publish_imu_data(const sensor_msgs::msg::Imu::SharedPtr msg)`**: Publishes an IMU message to the ROS topic
-
-**Constructor**
-
-```cpp
-HardwareInterface()
-```
-
-- Initializes ROS2 node with name `hardware_interface`
-- Creates a ROS2 publisher for `sensor_msgs::msg::Imu` on topic `imu_data` with queue size 10
-- Logs initialization status
-
-**Member Variables**
-
-- **`serialib serial`**: Encapsulates serial port communication
-- **`std::shared_ptr<mqtt::async_client> mqtt_client`**: Persistent MQTT async client for broker communication
-- **`std::shared_ptr<mqtt::callback> mqtt_cb`**: MQTT callback handler for message arrival events
-- **`std::thread read_thread_`**: Background reader thread for continuous serial data acquisition
-- **`std::atomic_bool reading_`**: Thread-safe flag to signal the reader thread to stop
-- **`std::string partial_buffer_`**: Accumulates fragmented serial reads until complete messages are available
-- **`rclcpp::Publisher<sensor_msgs::msg::Imu>::SharedPtr imu_publisher`**: ROS2 publisher for IMU data
-
-**MQTT Constants**
-
-- **`SERVER_ADDRESS`**: `"tcp://localhost:1883"` — Default MQTT broker address
-- **`CLIENT_ID`**: `"cpp_mqtt_client"` — MQTT client identifier
-- **`TOPIC`**: `"esp32/imu"` — Default subscription topic for IMU data
-
-## Core Functions
-
-### `void start_read()`
-
-Initiates continuous serial data acquisition in a background thread.
-
-**Behavior:**
-- Checks if a reader thread is already running; returns if so
-- Sets the `reading_` atomic flag to true
-- Spawns a thread that:
-  1. Allocates a 116-byte buffer
-  2. Enters a loop that runs while `reading_` is true
-  3. Calls `serial.readString()` with a 1-second timeout
-  4. Accumulates received bytes into `partial_buffer_`
-  5. Splits on newline (`\n`) to extract complete lines
-  6. Trims whitespace and strips leading garbage up to the first `{`
-  7. Validates that a closing `}` exists; if not, waits for more data
-  8. Calls `parse_data()` on each complete JSON line
-- Returns immediately while the thread continues running
-
-**Error Handling:**
-- Invalid JSON lines are logged as errors in `parse_data()` but do not crash the thread
-
-### `void stop_read()`
-
-Cleanly terminates the background reader thread.
-
-**Behavior:**
-- Returns immediately if not currently reading
-- Sets `reading_` atomic flag to false to signal the thread
-- Joins the thread to wait for its completion
-- Ensures all resources are released before returning
-
-**Thread Safety:**
-- Uses atomic flag for lock-free signaling
-- Blocks until thread joins, guaranteeing clean shutdown
-
-### `void parse_data(const std::string& data)`
-
-Deserializes a JSON string into a ROS2 IMU message and publishes it.
-
-**Behavior:**
-- Attempts to parse the input string as JSON using `nlohmann::json`
-- Creates a new `sensor_msgs::msg::Imu` message and populates:
-  - **Header**: Sets `stamp` to current time via `this->now()` and `frame_id` to `"imu_link"`
-  - **Linear Acceleration**: Extracts from JSON `"accel"` object fields `"x"`, `"y"`, `"z"` (defaults to 0.0 if missing)
-  - **Angular Velocity**: Extracts from JSON `"gyro"` object fields `"x"`, `"y"`, `"z"` (defaults to 0.0 if missing)
-- Logs the parsed IMU values at INFO level
-- Calls `publish_imu_data()` to send the message to the ROS topic
-
-**Expected JSON Format:**
-```json
-{
-  "accel": {"x": 0.037, "y": -1.164, "z": 9.775},
-  "gyro": {"x": -0.024, "y": -0.014, "z": -0.001},
-  "Temp": 41.01
-}
-```
-
-**Error Handling:**
-- Catches `nlohmann::json::exception` and logs parsing errors without crashing
-- Handles missing fields gracefully using `.value()` with default 0.0
-
-### `void publish_imu_data(const sensor_msgs::msg::Imu::SharedPtr msg)`
-
-Publishes an IMU message to the ROS2 topic.
-
-**Behavior:**
-- Dereferences the shared pointer and publishes to `imu_publisher`
-- Operation is thread-safe (rclcpp publishers support multi-threaded access)
-
-### `void mqtt_configure()`
-
-Sets up the MQTT infrastructure for broker communication.
-
-**Behavior:**
-- Creates a persistent `mqtt::async_client` pointing to `SERVER_ADDRESS` if not already created
-- Creates a persistent MQTT callback handler if not already created
-- Calls `mqtt_connect()` to establish the connection
-
-**Rationale for Persistence:**
-- Client and callback objects must outlive this function to maintain the connection
-- Using `shared_ptr` ensures proper lifetime management
-
-### `void mqtt_reader()`
-
-Attaches callbacks to the MQTT client to begin receiving messages.
-
-**Behavior:**
-- Sets the callback handler on the async client via `mqtt_client->set_callback(*mqtt_cb)`
-- Logs that the listener has started
-- Returns; the async client handles message reception in background threads
-
-### `void mqtt_connect()`
-
-Establishes connection to the MQTT broker and subscribes to the sensor topic.
-
-**Behavior:**
-- Creates `mqtt::connect_options` with:
-  - Keep-alive interval: 20 seconds
-  - Clean session: true (no prior session state restored)
-- Calls `mqtt_client->connect()` and waits for completion
-- Subscribes to `TOPIC` (default: `"esp32/imu"`) with QoS level 1
-- Logs successful connection and subscription
-
-**Error Handling:**
-- Catches `mqtt::exception` and logs errors; does not throw or crash
-
-### `void close_mqtt_conn()`
-
-Cleanly disconnects from the MQTT broker and cleans up resources.
-
-**Behavior:**
-- Checks if the client is connected before attempting disconnect
-- Calls `mqtt_client->disconnect()` and waits for completion
-- Resets `mqtt_client` and `mqtt_cb` shared pointers to allow object destruction
-- Logs disconnection and cleanup status
-
-**Error Handling:**
-- Catches `mqtt::exception` and logs errors
-- Continues cleanup even if errors occur
-
-### `bool open_device(const std::string& device_path, int baud_rate)`
-
-Opens and configures a serial port device.
-
-**Parameters:**
-- `device_path`: Path to the serial device (e.g., `"/dev/ttyUSB0"`)
-- `baud_rate`: Communication speed in bits per second (e.g., `115200`)
-
-**Returns:**
-- `true` if device opened successfully
-- `false` if an error occurs
-
-**Behavior:**
-- Calls `serial.openDevice()` with the provided path and baud rate
-- Checks if the returned value is 1 (success)
-- Logs success or error status
-
-### `bool is_device_open()`
-
-Queries the current state of the serial device.
-
-**Returns:**
-- `true` if the device is open
-- `false` otherwise
-
-### `void close_device()`
-
-Closes the serial port and releases resources.
-
-**Behavior:**
-- Calls `serial.closeDevice()`
-- Ensures the device is no longer accessible for reads/writes
-
-### `void write(const std::string& data)`
-
-Writes data to the serial device.
-
-**Behavior:**
-- Logs the write operation
-- Calls `serial.writeString()` with the data
-
-## MQTT Callback Handler
-
-### `class callback : public virtual mqtt::callback`
-
-A nested class that implements the Paho MQTT callback interface.
-
-**Method: `message_arrived(mqtt::const_message_ptr msg)`**
-
-- Invoked when a message arrives on a subscribed topic
-- Extracts the payload string via `msg->get_payload_str()`
-- Calls `parse_data()` to deserialize and publish the IMU message
-
-## Data Flow Architecture
-
-### Serial Data Path
-
-```
-Physical IMU Device
-         ↓
-Serial Port (e.g., /dev/ttyUSB0 @ 115200 baud)
-         ↓
-start_read() Background Thread
-         ↓
-serial.readString(buffer, 1000ms timeout)
-         ↓
-Accumulate into partial_buffer_
-         ↓
-Split on '\n' and Extract Complete Lines
-         ↓
-Sanitize (trim, strip garbage before '{')
-         ↓
-Validate JSON Structure (must have '{' and '}')
-         ↓
-parse_data(json_line)
-         ↓
-JSON Parse → sensor_msgs::msg::Imu
-         ↓
-publish_imu_data() → ROS Topic `imu_data`
-```
-
-### MQTT Data Path
-
-```
-MQTT Broker (tcp://localhost:1883)
-         ↓
-MQTT Async Client (mqtt_client)
-         ↓
-Topic Subscription (esp32/imu)
-         ↓
-MQTT Callback (message_arrived)
-         ↓
-parse_data(payload_string)
-         ↓
-JSON Parse → sensor_msgs::msg::Imu
-         ↓
-publish_imu_data() → ROS Topic `imu_data`
-```
-
-## Buffer Management & Message Reconstruction
-
-The `partial_buffer_` member implements a robust strategy for handling fragmented serial reads:
-
-1. **Accumulation**: Each serial read chunk is appended to `partial_buffer_`
-2. **Line Splitting**: Buffer is searched for newline delimiters
-3. **Validation**: Each line is checked for JSON structure (presence of `{` and `}`)
-4. **Sanitization**: Leading garbage (characters before `{`) is stripped
-5. **Incomplete Message Handling**: If a line lacks a closing brace, it's pushed back to the buffer and the loop waits for more data
-6. **Parse & Publish**: Complete JSON lines are parsed and published
-
-**Why This Matters:**
-- Serial reads may return fragments of a JSON message (e.g., `",\"gyro\":{...}"`)
-- Multiple messages can arrive in a single read
-- Buffering ensures robust handling of all edge cases
-
-## Error Handling & Recovery
-
-| Scenario | Behavior | Recovery |
-|----------|----------|----------|
-| Serial read timeout | Loop continues, checks `reading_` flag | Automatic retry on next iteration |
-| Incomplete JSON in buffer | Fragment is retained; waits for next read | No action needed; accumulation handles it |
-| JSON parse error | Error logged; thread continues listening | Move to next message |
-| Serial device disconnect | readString returns 0; loop continues | Application can reconnect via `open_device()` |
-| MQTT broker unreachable | Exception caught and logged | Retry via `mqtt_connect()` |
-| MQTT message error | Exception caught and logged | Connection remains for next message |
-
-## Thread Safety
-
-- **Atomic Flag**: `reading_` uses `std::atomic_bool` for lock-free thread signaling
-- **Publisher Thread-Safety**: rclcpp publishers are thread-safe; `parse_data()` can safely publish from reader thread
-- **Resource Cleanup**: `stop_read()` joins the thread before returning, ensuring clean shutdown
-- **No Shared Mutable State**: Aside from `reading_` and the publisher, thread does not access other class members during execution
-
----
-
-## Integration with LifecycleManager
-
-The `LifecycleManager` orchestrates `HardwareInterface` lifecycle:
-
-| Lifecycle Phase | LifecycleManager Call | HardwareInterface Action |
-|---|---|---|
-| **Configure** | `hw_interface->open_device()` or `mqtt_configure()` | Open serial port or set up MQTT client |
-| **Activate** | `hw_interface->start_read()` or `mqtt_reader()` | Spawn reader thread or attach MQTT callbacks |
-| **Deactivate** | `hw_interface->stop_read()` or `close_mqtt_conn()` | Stop reader thread and join; disconnect MQTT |
-| **Cleanup** | `hw_interface->close_device()` | Release serial port |
-
----
-
-## Usage Example
-
-### Direct Instantiation (Advanced)
-
-```cpp
-// Create an instance (normally managed by LifecycleManager)
-auto hw = std::make_shared<HardwareInterface>();
-
-// Serial workflow
-hw->open_device("/dev/ttyUSB0", 115200);
-hw->start_read();
-// ... node spins and publishes IMU data ...
-hw->stop_read();
-hw->close_device();
-
-// MQTT workflow
-hw->mqtt_configure();
-hw->mqtt_reader();
-// ... node spins and publishes IMU data ...
-hw->close_mqtt_conn();
-```
-
-## Design Patterns
-
-1. **Abstraction Pattern**: Encapsulates serial and MQTT complexity behind a unified interface
-2. **Thread Management**: Background reader thread with atomic signaling for clean shutdown
-3. **Buffer Accumulation**: Handles fragmented reads and multi-message batches robustly
-4. **Dual Backend Strategy**: Runtime selection of communication mode (serial or MQTT)
-5. **JSON Deserialization**: Uses industry-standard `nlohmann::json` for robust parsing
-
-## Dependencies
-
-- **rclcpp**: ROS2 C++ client library
-- **sensor_msgs**: ROS2 standard sensor message definitions
-- **paho-mqtt**: Paho C/C++ MQTT client library
-- **nlohmann/json**: Header-only JSON parsing library
-- **serialib**: Custom serial communication wrapper

doc/architecture/classes/Simulator.md

@@ -1,119 +0,0 @@
-# Simulator (`assignments::three::Simulator`)
-
-The `Simulator` class provides a flexible time-based value generation engine that supports multiple interpolation types. It is used by both the IMU and Wheel data simulator nodes to generate configurable sensor data patterns.
-
-## Implementation Details
-
-**Namespace**: `assignments::three`
-
-**Header**: `simulator/Simulator.hpp`
-
-### Data Structures
-
-**SimType Enum**
-```cpp
-enum class SimType {
-    CONSTANT,   // y = c (constant value)
-    LINEAR,     // y = y0 + (y1-y0) * (t-t0)/(t1-t0)
-    QUADRATIC   // Lagrange interpolation through 3 points
-};
-```
-
-**IntervalConfig Struct**
-```cpp
-struct IntervalConfig {
-    SimType type;    // Interpolation type
-    double t_start;  // Interval start time
-    double t_end;    // Interval end time
-    double y_start;  // Start value
-    double y_end;    // End value
-    double t_mid;    // Mid-point time (quadratic only)
-    double y_mid;    // Mid-point value (quadratic only)
-};
-```
-
-### Constructor
-```cpp
-Simulator(rclcpp::Node* node, const std::vector<std::string>& objects)
-```
-- Takes a ROS2 node pointer for parameter access
-- Takes a list of object/channel names to configure
-- Loads interval configurations from ROS2 parameters
-- Validates intervals for overlaps (throws `std::runtime_error` if detected)
-
-## Core Functionality
-
-**`double get_object_value(const std::string& object, double t)`**
-- Returns the simulated value for a given object at time `t`
-- If `t` is within an interval, computes the interpolated value
-- If `t` is after all intervals, holds the last interval's end value
-- If `t` is before all intervals, returns 0.0
-- If object doesn't exist, returns 0.0
-
-**`double compute_value(double t, const IntervalConfig& interval)`** (private)
-- Computes the interpolated value based on interval type:
-  - **CONSTANT**: Returns `y_start`
-  - **LINEAR**: Lagrange interpolation between 2 points
-  - **QUADRATIC**: Lagrange interpolation through 3 points
-
-**`void load_intervals(rclcpp::Node* node, const std::vector<std::string>& objects)`** (private)
-- Declares and loads parameters for each object
-- Validates that intervals don't overlap
-- Respects `max_intervals` limit
-
-## Parameter Configuration
-
-For each object, the following parameters are used:
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| `max_intervals` | int | Global maximum intervals per object |
-| `<object>.num_intervals` | int | Number of intervals for this object |
-| `<object>.interval_<n>.type` | string | "constant", "linear", or "quadratic" |
-| `<object>.interval_<n>.t_start` | double | Interval start time |
-| `<object>.interval_<n>.t_end` | double | Interval end time |
-| `<object>.interval_<n>.y_start` | double | Value at start |
-| `<object>.interval_<n>.y_end` | double | Value at end |
-| `<object>.interval_<n>.t_mid` | double | Mid-point time (quadratic) |
-| `<object>.interval_<n>.y_mid` | double | Mid-point value (quadratic) |
-
-## Example Configuration
-
-```yaml
-# Constant acceleration of 5.0 m/s² from t=0 to t=10
-linear_x:
-  num_intervals: 1
-  interval_0:
-    type: "constant"
-    t_start: 0.0
-    t_end: 10.0
-    y_start: 5.0
-
-# Linear ramp from 0 to 10 over 5 seconds
-wheel_fl:
-  num_intervals: 1
-  interval_0:
-    type: "linear"
-    t_start: 0.0
-    t_end: 5.0
-    y_start: 0.0
-    y_end: 10.0
-
-# Quadratic curve peaking at t=5
-angular_z:
-  num_intervals: 1
-  interval_0:
-    type: "quadratic"
-    t_start: 0.0
-    t_end: 10.0
-    y_start: 0.0
-    y_end: 0.0
-    t_mid: 5.0
-    y_mid: 3.14
-```
-
-## Error Handling
-
-- Throws `std::runtime_error` if overlapping intervals are detected for the same object
-- Logs warning for unknown interval types, defaults to CONSTANT
-- Returns 0.0 for non-existent objects (graceful degradation)

doc/architecture/interfaces/interfaces.md

@@ -0,0 +1,169 @@
+# ROS2 Interface Definitions - g2_2025_assign1_interfaces_pkg
+
+## Package Overview
+
+This document describes the custom ROS2 interface definitions in the `g2_2025_assign1_interfaces_pkg` package. These interfaces provide standardized communication protocols for the TI Minor Grade Generator system.
+
+**Package Name**: `g2_2025_assign1_interfaces_pkg`
+**Interface Types**: Messages, Services, Actions
+**Location**: `src/g2_2025_assign1_interfaces_pkg/`
+
+## Message Types (.msg)
+
+### Exam.msg
+
+Represents examination result data exchanged between system components.
+
+```
+string student_name
+string course_name
+int32 result
+builtin_interfaces/Time timestamp
+```
+
+**Field Descriptions**:
+- `student_name`: Name identifier for the student
+- `course_name`: Course identifier for the examination
+- `result`: Numerical exam result/grade (integer value)
+- `timestamp`: Timestamp of the message
+
+**Usage**: Primary message type for exam result communication between ExamResultGenerator and grade processing nodes.
+
+### Student.msg
+
+Represents student information and course enrollment data.
+
+```
+string student_name
+string course_name
+builtin_interfaces/Time timestamp
+```
+
+**Field Descriptions**:
+- `student_name`: Name identifier for the student
+- `course_name`: Course identifier for enrollment/management
+- `timestamp`: Timestamp of the message
+
+**Usage**: Used for student-course management operations and enrollment tracking.
+
+## Service Definitions (.srv)
+
+### Exams.srv
+
+Service interface for grade calculation operations using multiple exam results.
+
+#### Request
+```
+string student_name
+string course_name
+int32[] exam_grades
+```
+
+#### Response
+```
+int32 result  # Final calculated result
+```
+
+**Request Fields**:
+- `student_name`: Student identifier for grade calculation
+- `course_name`: Course identifier for context
+- `exam_grades`: Array of exam grades to be processed
+
+**Response Fields**:
+- `result`: Final calculated grade result (integer value)
+
+**Usage**: Main service interface used by GradeCalculator node for processing multiple exam grades into final results.
+
+## Action Definitions (.action)
+
+### Retake.action
+
+Action interface for managing retake exam scheduling and processing workflows.
+
+#### Goal
+```
+string student_name
+string course_name
+```
+
+#### Result
+```
+float32 result
+```
+
+#### Feedback
+```
+string status
+```
+
+**Goal Fields**:
+- `student_name`: Student for which a retake is requested
+- `course_name`: Course for which a retake is requested
+
+**Result Field**
+- `result`: Progress indicator or intermediate result (float value) (*Not Implemented*)
+
+**Feedback Field**:
+- `status`: Status indicator (*Not Implemented*)
+
+**Usage**: Used by RetakeScheduler node to handle long-running retake management operations with progress feedback.
+
+## Node Interface Usage
+
+### ExamResultGenerator Node
+
+**Publishers**:
+- **Topic**: `exam_results`
+- **Message Type**: `g2_2025_assign1_interfaces_pkg::msg::Exam`
+- **Purpose**: Publishes generated exam results to downstream processing nodes
+- **Rate**: Configurable interval (default: 2 seconds)
+
+**Subscribers**:
+- **Topic**: `student_course_management`
+- **Message Type**: `g2_2025_assign1_interfaces_pkg::msg::Student`
+- **Purpose**: Receives student-course enrollment updates for exam generation queue
+
+### FinalGradeDeterminator Node
+
+**Subscribers**:
+- **Topic**: `exam_results`
+- **Message Type**: `g2_2025_assign1_interfaces_pkg::msg::Exam`
+- **Purpose**: Collects exam results for grade calculation processing
+
+**Service Clients**:
+- **Service**: `calculate_grade`
+- **Service Type**: `g2_2025_assign1_interfaces_pkg::srv::Exams`
+- **Purpose**: Requests grade calculation from GradeCalculator when threshold is met
+
+**Publishers**:
+- **Topic**: `student_course_management`
+- **Message Type**: `g2_2025_assign1_interfaces_pkg::msg::Student`
+- **Purpose**: Communicate end of enrollment when grade has been calculated
+
+### GradeCalculator Node
+
+**Service Servers**:
+- **Service**: `calculate_grade`
+- **Service Type**: `g2_2025_assign1_interfaces_pkg::srv::Exams`
+- **Purpose**: Provides grade calculation services for multiple exam grades
+- **Processing**: Applies business logic (averaging, bonus points, validation)
+
+### RetakeScheduler Node
+
+**Action Servers**:
+- **Action**: `retake_request`
+- **Action Type**: `g2_2025_assign1_interfaces_pkg::action::Retake`
+- **Purpose**: Handles long-running retake scheduling operations
+- **Feedback**: Provides progress updates during scheduling process
+
+### RetakeGradeDeterminator Node
+
+**Service Clients**:
+- **Service**: `calculate_grade`
+- **Service Type**: `g2_2025_assign1_interfaces_pkg::srv::Exams`
+- **Purpose**: Requests specialized retake grade calculations
+
+**Subscribers**:
+- **Topic**: `retake_results`
+- **Message Type**: `g2_2025_assign1_interfaces_pkg::msg::Exam`
+- **Purpose**: Processes completed retake exam results

doc/architecture/managers/ConfigManager.md

@@ -84,7 +84,7 @@ std::vector<std::string> default_config_paths_ = {
 #### Default Values and Fallbacks
 - **host**: `"localhost"` - Local database server
 - **port**: `5432` - Standard PostgreSQL port
-- **dbname**: `"imu_data"` - Application-specific database
+- **dbname**: `"grades"` - Application-specific database
 - **user**: `"postgres"` - Default PostgreSQL user
 - **password**: `"postgres"` - Default PostgreSQL password
 - **timeout**: `30` seconds - connection timeout
@@ -121,7 +121,7 @@ Example complete TOML configuration:
 [database]
 host = "localhost"
 port = 5432
-dbname = "imu_data"
+dbname = "grades"
 user = "postgres"
 password = "postgres"
 timeout = 30

doc/architecture/managers/DatabaseManager.md

@@ -1,9 +1,9 @@
-# DatabaseManager (`assignments::two::DatabaseManager`)
+# DatabaseManager (`assignments::one::DatabaseManager`)
 
 ## Overview
 
-The `DatabaseManager` class is a PostgreSQL database interface for the ROS2 IMU data collection system.
-It handles all database operations including connection management, table creation and data storage.
+The `DatabaseManager` class is a PostgreSQL database interface for the ROS2 grade calculator.
+It handles all database operations including connection management, table creation and data insertion.
 
 ## Implementation Details
 
@@ -28,7 +28,7 @@ DatabaseManager(rclcpp::Logger logger)
 > Returns `true` on successful connection, `false` on failure
 
 - Establishes connection to PostgreSQL database using connection information from the config TOML
-- Connection string format: `"host=localhost port=5432 dbname=imu_data user=postgres password=postgres"`
+- Connection string format: `"host=localhost port=5432 dbname=grades user=postgres password=postgres"`
 
 **`bool is_connected() const`**
 >  Returns `true` if connection exists and is open
@@ -47,25 +47,56 @@ DatabaseManager(rclcpp::Logger logger)
 **`void create_tables()`**
 - Creates all required database tables using SQL queries from `SQLQueries.hpp`
 - Tables created:
-  - `imu_data`: IMU sensor readings with linear acceleration and angular velocity data
+  - `enrollments`: Student course enrollments
+  - `exam_results`: Individual exam scores
+  - `course_results`: Final course grades and statistics
 - Uses transactions for atomic table creation
 
+**`void insert_sample_data()`**
+- Inserts predefined sample student data
+
 ### Data Operations
 
-#### IMU Data Storage
+#### Student Course Management
 
-**`bool store_imu_data(double linear_accel_x, double linear_accel_y, double linear_accel_z, double angular_vel_x, double angular_vel_y, double angular_vel_z)`**
-> Returns `true` on successful storage, `false` on failure
+**`std::vector<StudentCourse> queue_pending_combinations()`**
+> Returns vector of StudentCourse objects for processing queue
 
-- Stores IMU sensor readings in the database
+- Gets all student-course combinations that need exam results generated
+- Executes complex SQL query to find missing exam results
+
+**`bool enroll_student_into_course(const StudentCourse& sc)`**
+> Returns `true` on successful enrollment, `false` on failure
+
+- Enrolls a student into a specific course
+
+#### Exam Result Processing
+
+**`bool store_exam_result(const std::string& student_name, const std::string& course_name, int grade)`**
+- Stores individual exam results in the database
 - Parameters:
-  - `linear_accel_x`: Linear acceleration on X-axis
-  - `linear_accel_y`: Linear acceleration on Y-axis
-  - `linear_accel_z`: Linear acceleration on Z-axis
-  - `angular_vel_x`: Angular velocity around X-axis
-  - `angular_vel_y`: Angular velocity around Y-axis
-  - `angular_vel_z`: Angular velocity around Z-axis
-- Automatically adds timestamp on insertion
+  - `student_name`: Name of the student
+  - `course_name`: Name of the course
+  - `grade`: Exam score (10-100)
+
+**`bool store_final_course_result(const StudentCourse& sc, int exam_count, int final_grade)`**
+- Stores calculated final course results
+- Parameters:
+  - `sc`: StudentCourse object containing student and course names
+  - `exam_count`: Number of exams taken
+  - `final_grade`: Calculated final grade
+- Used by grade calculation nodes for final result storage
+
+#### Grade Retrieval
+
+**`int get_final_course_grade(const StudentCourse& sc)`**
+> Returns:
+>  - `> 0`: Valid final grade (rounded average)
+>  - `-1`: No exams taken or no results found
+
+- Gets final calculated grade for a student-course combination
+- Performs average calculation with proper rounding
+- Used by nodes to check if final grading is complete
 
 ### Logging
 
@@ -86,9 +117,9 @@ DatabaseManager db_manager(node->get_logger());
 // Check connection status
 if (db_manager.is_connected()) {
     // Database ready for operations
-    bool success = db_manager.store_imu_data(1.2, -0.5, 9.8, 0.01, 0.02, 0.03);
+    bool success = db_manager.store_exam_result("Wessel", "ROS2", 85);
     if (success) {
-        RCLCPP_INFO(logger, "IMU data stored successfully");
+        RCLCPP_INFO(logger, "Exam result stored successfully");
     }
 }
 ```

doc/architecture/nodes/DatabaseHandlerNode.md

@@ -1,41 +0,0 @@
-# DatabaseHandlerNode (`assignments::three::g2_2025_database_node`)
-
-The `DatabaseHandlerNode` subscribes to position and velocity topics and stores the data in a
-PostgreSQL database via the `DatabaseManager`.
-
-## Implementation Details
-
-**Parameters**
-
-| Parameter | Type | Default | Description |
-|-----------|------|---------|-------------|
-| `save_position_data` | bool | true | Enable storage of position |
-| `save_velocity_data` | bool | true | Enable storage of velocity |
-
-**Constructor**
-```cpp
-DatabaseHandlerNode()
-```
-- Initializes ROS2 node with name `database_handler_node`
-- Creates subscriptions to `estimated_position` and/or `estimated_velocity` based on parameter configuration
-
-## Functions
-
-**`void position_callback(const geometry_msgs::msg::Pose2D::SharedPtr msg)`**
-- Primary callback invoked whenever a position message is received
-- Forwards: x, y, and theta to `DatabaseManager::store_position_data`
-- Throttled warning (5 second interval) on storage failures
-
-**`void velocity_callback(const geometry_msgs::msg::Twist::SharedPtr msg)`**
-- Primary callback invoked whenever a velocity message is received
-- Forwards: linear velocity (x, y, z) and angular velocity (z) to `DatabaseManager::store_velocity_data`
-- Throttled warning (5 second interval) on storage failures
-
-## ROS2 Interface
-
-**Subscriptions**
-- `estimated_position` (geometry_msgs/msg/Pose2D)
-  - Receives calculated position estimates (only subscribed if `save_position_data=true`)
-
-- `estimated_velocity` (geometry_msgs/msg/Twist)
-  - Receives calculated velocity estimates (only subscribed if `save_velocity_data=true`)

doc/architecture/nodes/ExamResultGenerator.md

@@ -0,0 +1,42 @@
+# ExamResultGenerator (`assignments::one::g2_2025_exam_result_generator_node`)
+
+## Overview
+The `ExamResultGenerator` is the core node responsible for simulating exam result generation.
+It maintains a queue of student-course combinations that need exam results, generates random
+grades, and publishes them to the system.
+
+#### Implementation Details
+
+**Parameters**
+
+- **`delay_between_grades_ms`** (int, default: 2000): Delay (in milliseconds) between generated grades.
+
+**Constructor**
+```cpp
+ExamResultGenerator()
+```
+- Initializes ROS2 node with name `g2_2025_exam_result_generator_node`
+- Sets up random number generation infrastructure
+- Creates DatabaseManager instance with node logger
+- Establishes ROS2 publishers, subscribers, and timers
+- Loads initial pending combinations from database
+
+**Core Functions**
+
+**`void queue_pending_combinations()`**
+- Gets all student-course combinations needing exam results
+- Populates operations queue from database
+- Called at initialization and when database state changes
+
+**`void generate_random_result()`**
+- Main exam result generation executed by timer
+- Selects random student-course combination from queue
+- Stores result in database and publishes to ROS2 topic
+
+**`void student_management_callback(const g2_2025_assign1_interfaces_pkg::msg::Student::SharedPtr msg)`**
+- Toggles combinations in/out of processing queue
+- Updates database with new enrollments
+
+**`void add_student_course_combination(const StudentCourse& sc)`**
+- Enrolls student into course via database
+- Adds combination to processing queue

doc/architecture/nodes/FinalGradeDeterminator.md

@@ -0,0 +1,39 @@
+# FinalGradeDeterminator (`assignments::one::g2_2025_final_grade_determinator_node`)
+
+## Overview
+The `FinalGradeDeterminator` node collects exam results for student-course combinations, triggers grade calculation when enough results are gathered, and stores final grades in the database. It interacts with ROS2 publishers, subscribers, and service clients to manage the grading workflow.
+
+#### Implementation Details
+
+**Parameters**
+
+- **`grade_collection_amount`** (int, default: 5): Number of exam results required before triggering grade calculation for a student-course combination.
+
+**Constructor**
+```cpp
+FinalGradeDeterminator()
+```
+- Initializes ROS2 node with name `g2_2025_final_grade_determinator_node`
+- Declares and retrieves `grade_collection_amount` parameter
+- Sets up `DatabaseManager`
+- Creates publisher for student course management
+- Subscribes to exam results topic
+- Initializes service client for grade calculation
+
+**Core Functions**
+
+**`void exam_results_callback(const g2_2025_assign1_interfaces_pkg::msg::Exam::SharedPtr msg)`**
+- Updates internal map with received exam result for student-course combo
+- Checks if enough results have been collected
+- Triggers grade calculation request when threshold is met
+
+**`void grade_calculator_request(StudentCourse combo)`**
+- Waits for grade calculator service to be available
+- Sends async request with collected exam grades for the student-course combination
+- Uses callback to handle service response
+
+**`void grade_calculator_response(rclcpp::Client<g2_2025_assign1_interfaces_pkg::srv::Exams>::SharedFuture future, StudentCourse studentCourseCombo)`**
+- Verifies database connection
+- Publishes final student message to ROS2 topic
+- Logs final grade information
+- Stores final course result in database

doc/architecture/nodes/GradeCalculator.md

@@ -0,0 +1,25 @@
+# GradeCalculator (`assignments::one::g2_2025_grade_calculator_node::GradeCalculator`)
+
+## Overview
+The `GradeCalculator` node provides a ROS2 service for calculating student exam grades. It processes exam scores, applies custom logic for specific student names, and ensures grade results are within valid bounds.
+
+#### Implementation Details
+
+**Constructor**
+```cpp
+GradeCalculator()
+```
+- Initializes ROS2 node with name `g2_2025_grade_calculator_node`
+- Creates a ROS2 service server for `grade_calculator_service`
+- Binds the service callback to handle grade calculation requests
+- Logs service startup
+
+**Core Functions**
+
+**`void grade_calculator_callback(const Exams::Request::SharedPtr request, const Exams::Response::SharedPtr response)`**
+- Checks if exam grades are provided
+- Calculates the total and average of exam grades
+- Converts student name to lowercase for comparison
+- Adds a bonus of 10 points if the student name is "wessel"
+- Ensures the final grade is clamped between 10 and 100
+- Sends the calculated grade back through the service response

doc/architecture/nodes/IMUDataSimulator.md

@@ -1,64 +0,0 @@
-# IMUDataSimulator (`assignments::three::data_simulator_node`)
-
-The `IMUDataSimulator` node generates simulated IMU sensor data (`sensor_msgs/msg/Imu`) based on configurable time-varying intervals. It publishes linear acceleration and angular velocity values that can follow constant, linear, or quadratic trajectories over time.
-
-## Implementation Details
-
-**Parameters**
-
-| Parameter | Type | Default | Description |
-|-----------|------|---------|-------------|
-| `publish_rate` | double | 10.0 | Publishing frequency in Hz |
-| `max_intervals` | int | 4 | Maximum number of intervals per axis |
-| `<axis>.num_intervals` | int | 0 | Number of intervals for each axis |
-| `<axis>.interval_<n>.*` | various | - | Interval configuration (see Simulator) |
-
-**Axes Configured:**
-- `linear_x`, `linear_y`, `linear_z` - Linear acceleration axes
-- `angular_x`, `angular_y`, `angular_z` - Angular velocity axes
-
-**Constructor**
-```cpp
-DataSimulator()
-```
-- Initializes ROS2 node with name `imu_data_simulator`
-- Creates `Simulator` instance for value generation
-- Creates publisher for `simulated_imu_data` topic
-- Sets up timer for periodic publishing
-
-## Core Functionality
-
-**`void publish_imu_data()`**
-- Timer callback invoked at the configured publish rate
-- Calculates elapsed time since node start
-- Queries `Simulator` for current values of all 6 axes
-- Populates IMU message with:
-  - Header timestamp and frame_id (`imu_link`)
-  - Linear acceleration (x, y, z)
-  - Angular velocity (x, y, z)
-- Publishes message to topic
-
-## ROS2 Interface
-
-**Publications**
-- `simulated_imu_data` (sensor_msgs/msg/Imu)
-  - Publishes simulated IMU data at configured rate
-  - Frame ID: `imu_link`
-
-## Usage Example
-
-```bash
-ros2 run g2_2025_odometry_pkg imu_data_simulator_node --ros-args \
-  -p publish_rate:=20.0 \
-  -p linear_x.num_intervals:=1 \
-  -p linear_x.interval_0.type:=constant \
-  -p linear_x.interval_0.t_start:=0.0 \
-  -p linear_x.interval_0.t_end:=10.0 \
-  -p linear_x.interval_0.y_start:=9.81
-```
-
-## Dependencies
-
-- `rclcpp` - ROS2 C++ client library
-- `sensor_msgs` - Standard sensor message types
-- `Simulator` - Internal simulation engine

doc/architecture/nodes/IMUDatabaseWriter.md

@@ -1,29 +0,0 @@
-# IMUDatabaseWriter (`assignments::two::imu_database_writer`)
-
-The `IMUDatabaseWriter` node subscribes to IMU sensor data (`sensor_msgs/msg/Imu`) and saves published data into the PostgreSQL database via the `DatabaseManager`. It is a lightweight sink node intended record IMU measurements (linear acceleration and angular velocity) together with timestamps.
-
-## Implementation Details
-
-**Parameters**
-
-- No node-specific parameters are required by default. Database connection and table configuration are handled by `DatabaseManager` and the project's `ConfigManager`.
-
-**Constructor**
-```cpp
-IMUDatabaseWriter()
-```
-- Initializes ROS2 node with name `imu_database_writer`
-- Creates `DatabaseManager` instance
-- Creates a subscription to the `imu_data` topic using `sensor_msgs::msg::Imu`
-
-## Core Functionality
-
-**`void imu_data_callback(const sensor_msgs::msg::Imu::SharedPtr msg)`**
-- Primary callback invoked whenever an IMU message is received
-- Forwards: linear acceleration (x, y, z) and angular velocity (x, y, z) to `DatabaseManager::store_imu_data`
-
-## ROS2 Interface
-
-**Subscriptions**
-- `imu_data` (sensor_msgs/msg/Imu)
-  - Receives raw IMU samples.

doc/architecture/nodes/IMUPositionApproximator.md

@@ -1,58 +0,0 @@
-# IMUPositionApproximator (`assignments::three::g2_2025_imu_position_approximator_node`)
-
-The `IMUPositionApproximator` node calculates position and velocity estimates by integrating
-acceleration data from an IMU sensor. It transforms sensor data from the robot frame to the
-map frame, accounting for rotations and centripetal effects, and provides a position reset
-topic.
-
-## Implementation Details
-
-**Parameters**
-
-| Parameter | Type | Default | Description |
-|-----------|------|---------|-------------|
-| `initial_x` | double | 0.0 | Initial x position in map frame |
-| `initial_y` | double | 0.0 | Initial y position in map frame |
-| `initial_z` | double | 0.0 | Initial z position in map frame |
-| `initial_theta` | double | 0.0 | Initial orientation angle (radians) |
-| `imu_topic` | string | "imu_data" | Topic name for IMU sensor data |
-
-**Constructor**
-```cpp
-IMUPositionApproximator()
-```
-- Initializes ROS2 node with name `imu_position_approximator`
-- Creates subscription to IMU topic (configurable) and `position_reset` topic
-- Creates publishers for `estimated_position` and `estimated_velocity`
-
-## Functions
-
-**`void imu_callback(const sensor_msgs::msg::Imu::SharedPtr msg)`**
-- Primary callback invoked whenever an IMU message is received
-- Calculates time delta `dt` between measurements; skips invalid deltas (≤0 or >1 second)
-- Updates orientation: `theta += omega_z * dt` and normalizes to [-pi, pi]
-- Applies gravity compensation: subtracts 9.81 m/s^2 from z-axis acceleration
-- Transforms acceleration from robot frame to map frame using rotation matrix
-- Corrects for centripetal acceleration due to rotation
-- Integrates acceleration to update velocity, then integrates velocity to update position
-- Publishes `estimated_position` (Pose2D) and `estimated_velocity` (Twist)
-
-**`void position_reset_callback(const geometry_msgs::msg::Pose2D::SharedPtr msg)`**
-- Updates position (x, y) and orientation (theta) to provided values
-- Resets all velocities (vx, vy, vz) to zero
-
-## ROS2 Interface
-
-**Subscribers**
-- `imu_data` (sensor_msgs/msg/Imu) [configurable via `imu_topic` parameter]
-  - Receives raw IMU sensor data with linear acceleration and angular velocity
-
-- `position_reset` (geometry_msgs/msg/Pose2D)
-  - Receives position reset commands from external position determinator
-
-**Publishers**
-- `estimated_position` (geometry_msgs/msg/Pose2D)
-  - Publishes calculated position (x, y, theta) in map frame
-
-- `estimated_velocity` (geometry_msgs/msg/Twist)
-  - Publishes calculated linear velocities (x, y, z) and angular velocity (z)

doc/architecture/nodes/LifecycleManager.md

@@ -1,215 +0,0 @@
-# LifecycleManager (`assignments::two::g2_2025_lifecycle_node`)
-
-## Overview
-The `LifecycleManager` is the core lifecycle-aware node responsible for managing the IMU reader system's operational states and hardware communication. It orchestrates transitions between configuration, activation, and deactivation phases, abstracting the complexity of dual communication backends (serial and MQTT) into a unified interface.
-
-#### Implementation Details
-
-**Parameters**
-
-- **`device_path`** (string, default: "/dev/ttyUSB0"): Serial device path for hardware connection (e.g., USB serial adapter).
-- **`baudrate`** (int, default: 115200): Serial communication baud rate in bits per second.
-- **`comm_t`** (string, default: "serial"): Communication type selector—either "serial" or "mqtt" to determine which backend to use.
-
-**Constructor**
-```cpp
-LifecycleManager()
-```
-- Initializes ROS2 lifecycle node with name `lifecycle_manager`
-- Declares and reads configuration parameters: `device_path`, `baudrate`, and `comm_t`
-- Creates a shared instance of `HardwareInterface` for managing all hardware operations
-- Logs initialization status and readiness
-
-**Core Functions**
-
-**`CallbackReturn on_configure(const State&)`**
-- Enters the *Unconfigured* → *Inactive* transition
-- Checks the `comm_t` parameter to route initialization:
-  - **MQTT mode**: Calls `hw_interface->mqtt_configure()` to set up the MQTT client and broker connection
-  - **Serial mode**: Calls `hw_interface->open_device(device_path_, baudrate_)` to open and configure the serial port
-- Returns `SUCCESS` if device initialization succeeds, `FAILURE` if serial/MQTT setup fails
-- Logs configuration status and any errors
-- Example test code (currently commented) demonstrates direct JSON parsing for validation
-
-**`CallbackReturn on_activate(const State&)`**
-- Enters the *Inactive* → *Active* transition
-- Checks the `comm_t` parameter to start the appropriate reader:
-  - **MQTT mode**: Calls `hw_interface->mqtt_reader()` to attach MQTT callbacks and begin receiving messages
-  - **Serial mode**: Calls `hw_interface->start_read()` to spawn a background thread that continuously reads from the serial device
-- Returns `SUCCESS` after reader startup
-- Logs activation status and selected communication type
-
-**`CallbackReturn on_deactivate(const State&)`**
-- Enters the *Active* → *Inactive* transition
-- Checks the `comm_t` parameter to cleanly stop operations:
-  - **MQTT mode**: Calls `hw_interface->close_mqtt_conn()` to disconnect from the broker and clean up resources
-  - **Serial mode**:
-    - Verifies device state with `hw_interface->is_device_open()`
-    - Calls `hw_interface->stop_read()` to signal the reader thread to exit and joins it
-    - Calls `hw_interface->close_device()` to release the serial port
-- Returns `SUCCESS` after cleanup completes
-- Logs deactivation and resource release
-
-**`CallbackReturn on_shutdown(const State&)`**
-- Enters the *Inactive* → *Finalized* transition
-- Performs final shutdown logging
-- Returns `SUCCESS`
-
-**`CallbackReturn on_cleanup(const State&)`**
-- Called during error recovery or explicit cleanup commands
-- Performs resource cleanup and state logging
-- Returns `SUCCESS`
-
-
-## Communication Architecture
-
-### Dual Backend Support
-
-The `LifecycleManager` provides a flexible, pluggable communication architecture via the `comm_t` parameter:
-
-#### Serial Communication Path
-1. **Configuration Phase** (`on_configure`):
-   - Opens the serial device at the path specified by `device_path` and baudrate
-   - Validates device readiness
-
-2. **Activation Phase** (`on_activate`):
-   - Spawns a background reader thread via `hw_interface->start_read()`
-   - Thread continuously polls the serial device with a timeout
-   - Reads are accumulated in a partial buffer, split on newline, and parsed as JSON
-   - Each valid JSON IMU payload is parsed into a `sensor_msgs::msg::Imu` and published to the ROS topic `imu/data`
-
-3. **Deactivation Phase** (`on_deactivate`):
-   - Signals the reader thread to stop via atomic flag
-   - Joins the thread to ensure clean termination
-   - Closes the serial device
-
-#### MQTT Communication Path
-1. **Configuration Phase** (`on_configure`):
-   - Creates a persistent MQTT async client pointing to the broker at `SERVER_ADDRESS` (default: `tcp://localhost:1883`)
-   - Initializes MQTT callback infrastructure
-
-2. **Activation Phase** (`on_activate`):
-   - Attaches MQTT callbacks to the client
-   - Subscribes to the topic specified by `TOPIC` (default: `esp32/imu`)
-   - The async client runs background threads to receive messages
-
-3. **Deactivation Phase** (`on_deactivate`):
-   - Disconnects from the broker
-   - Cleans up MQTT client and callback resources
-
-## Lifecycle Commands
-
-To interact with the `LifecycleManager` from the command line, use the following ROS2 lifecycle service calls:
-
-```bash
-# List current lifecycle state
-ros2 lifecycle list /LifecycleManager
-
-# Transition: UNCONFIGURED -> INACTIVE
-ros2 lifecycle set /LifecycleManager configure
-
-# Transition: INACTIVE -> UNCONFIGURED
-ros2 lifecycle set /LifecycleManager cleanup
-
-# Transition: INACTIVE -> ACTIVE
-ros2 lifecycle set /LifecycleManager activate
-
-# Transition: ACTIVE -> INACTIVE
-ros2 lifecycle set /LifecycleManager deactivate
-
-# Transition: INACTIVE -> FINALIZED
-ros2 lifecycle set /LifecycleManager shutdown
-```
-![img](https://design.ros2.org/img/node_lifecycle/life_cycle_sm.png)
-
-## Data Flow
-
-### Serial Data Flow
-```
-Hardware Device
-      ↓
-Serial Port (/dev/ttyUSB0)
-      ↓
-Background Reader Thread (start_read)
-      ↓
-Partial Buffer Accumulation
-      ↓
-JSON Line Extraction & Sanitization
-      ↓
-parse_data() ← Deserializes JSON to sensor_msgs::msg::Imu
-      ↓
-imu_publisher → ROS2 Topic (`imu_data`)
-```
-
-### MQTT Data Flow
-```
-MQTT Broker (localhost:1883)
-      ↓
-MQTT Async Client (Background Thread)
-      ↓
-Subscription to Topic (esp32/imu)
-      ↓
-MQTT Callback Handler
-      ↓
-parse_data() ← Deserializes JSON to sensor_msgs::msg::Imu
-      ↓
-imu_publisher → ROS2 Topic (`imu_data`)
-```
-
-## Error Handling
-
-- **Serial Device Failures**: If `open_device()` fails during configuration, `on_configure()` returns `FAILURE` and the system remains in the `UNCONFIGURED` state
-- **Communication Errors**: JSON parse errors from invalid payloads are caught and logged without crashing the node; the reader continues listening for the next message
-- **Thread Safety**: The reader thread uses an atomic flag (`reading_`) for clean stop signaling and ensures all resources are properly joined before returning from `on_deactivate()`
-
-## Design Patterns
-
-1. **Strategy Pattern**: The `comm_t` parameter enables runtime selection of communication backend without changing node code
-2. **Lifecycle Pattern**: Follows ROS2 managed node pattern for predictable initialization, startup, and shutdown sequences
-3. **Thread Safety**: Atomic flags and resource cleanup ensure the reader thread can be safely started and stopped
-4. **Buffer Accumulation**: Partial message buffering handles fragmented serial reads and ensures complete JSON objects are parsed
-
-## Integration with HardwareInterface
-
-The `LifecycleManager` delegates all hardware operations to the `HardwareInterface` class:
-
-| Operation | Method | Lifecycle Phase |
-|-----------|--------|-----------------|
-| Open serial device | `open_device(path, baud)` | on_configure |
-| Start reading | `start_read()` | on_activate |
-| Stop reading | `stop_read()` | on_deactivate |
-| Close serial device | `close_device()` | on_deactivate |
-| Configure MQTT | `mqtt_configure()` | on_configure |
-| Start MQTT reading | `mqtt_reader()` | on_activate |
-| Close MQTT connection | `close_mqtt_conn()` | on_deactivate |
-| Parse JSON payload | `parse_data(json_string)` | on_activate (continuous) |
-| Publish IMU message | `publish_imu_data(imu_msg)` | on_activate (continuous) |
-
-## Usage Example
-
-```bash
-# Launch the node with serial communication at /dev/ttyUSB0, 115200 baud
-ros2 run g2_2025_imu_reader_pkg g2_2025_lifecycle_node \
-  --ros-args \
-  -p device_path:=/dev/ttyUSB0 \
-  -p baudrate:=115200 \
-  -p comm_t:=serial
-
-# Alternatively, launch with MQTT communication
-ros2 run g2_2025_imu_reader_pkg g2_2025_lifecycle_node \
-  --ros-args \
-  -p comm_t:=mqtt
-
-# In another terminal, configure and activate the lifecycle
-ros2 lifecycle set /LifecycleManager configure
-ros2 lifecycle set /LifecycleManager activate
-
-# Subscribe to published IMU data
-ros2 topic echo /imu_data
-
-# Deactivate and shutdown
-ros2 lifecycle set /LifecycleManager deactivate
-ros2 lifecycle set /LifecycleManager shutdown
-```
-
----

doc/architecture/nodes/RetakeGradeDeterminator.md

@@ -0,0 +1,60 @@
+# RetakeGradeDeterminator (`assignments::one::g2_2025_retake_grade_determinator_node`)
+
+## Overview
+The `RetakeGradeDeterminator` node handles the processing of retake exams for students who have
+failed courses. It provides a ROS2 action server that accepts retake requests, manages exam result
+collection for retake scenarios, and coordinates with the grade calculator service to determine
+final retake grades.
+
+#### Implementation Details
+
+**Parameters**
+
+- **`grade_collection_amount`** (int, default: 5): Number of exam results required before triggering grade calculation for a retake student-course combination.
+
+**Constructor**
+```cpp
+RetakeGradeDeterminator(std::unique_ptr<DatabaseManager> db_manager = nullptr)
+```
+- Initializes ROS2 node with name `g2_2025_retake_grade_determinator_node`
+- Sets up `DatabaseManager` (optional injection for testing)
+- Creates publisher for student course management
+- Subscribes to exam results topic with retake-specific callback
+- Initializes service client for grade calculation
+- Creates ROS2 action server for retake requests with reentrant callback group
+
+**Core Functions**
+
+**`void exam_results_callback(const g2_2025_assign1_interfaces_pkg::msg::Exam::SharedPtr msg)`**
+- Only processes exam results when `retake_allowed_` flag is true
+- Triggers grade calculation request when threshold is met
+
+**`void grade_calculator_request(StudentCourse combo)`**
+- Waits for grade calculator service to be available
+- Sends async request with collected retake exam grades
+
+**`void grade_calculator_response(rclcpp::Client<g2_2025_assign1_interfaces_pkg::srv::Exams>::SharedFuture future, StudentCourse studentCourseCombo)`**
+- Clears collected exam data from internal map
+- Updates retake status in database for the student-course combination
+- Publishes final student message to ROS2 topic with timestamp
+- Stores final course result in database with retake flag set to true
+
+**Action Server Callbacks**
+
+**`rclcpp_action::GoalResponse goal_callback(const rclcpp_action::GoalUUID& uuid, std::shared_ptr<const g2_2025_assign1_interfaces_pkg::action::Retake::Goal> goal)`**
+- Accepts retake goal requests for specific student-course combinations
+- Logs received retake requests with student and course information
+- Returns `ACCEPT_AND_EXECUTE` for all valid requests
+
+**`rclcpp_action::CancelResponse cancel_callback(const std::shared_ptr<rclcpp_action::ServerGoalHandle<g2_2025_assign1_interfaces_pkg::action::Retake>> goal_handle)`**
+- Handles retake action cancellation requests
+- Returns `ACCEPT` for all cancellation requests
+
+**`void spawn_callback_thread(const std::shared_ptr<rclcpp_action::ServerGoalHandle<g2_2025_assign1_interfaces_pkg::action::Retake>> goal_handle)`**
+- Creates detached thread for asynchronous retake action execution
+- Ensures non-blocking retake processing
+
+**`void async_execute_callback_thread(const std::shared_ptr<rclcpp_action::ServerGoalHandle<g2_2025_assign1_interfaces_pkg::action::Retake>> goal_handle)`**
+- Enables retake exam processing by setting `retake_allowed_` flag
+- Publishes student enrollment message to trigger exam generation
+- Creates and returns successful action result

doc/architecture/nodes/RetakeScheduler.md

@@ -0,0 +1,47 @@
+# RetakeScheduler (`assignments::one::g2_2025_retake_scheduler_node`)
+
+## Overview
+The `RetakeScheduler` node automatically identifies students who have failed courses and schedules retake exams for them. It periodically queries the database for failing students and sends retake action requests to the `RetakeGradeDeterminator` node to initiate the retake process.
+
+#### Implementation Details
+
+**Parameters**
+
+- **`retake_check_interval_sec`** (int, default: 120): Time interval in seconds between checks for failing students requiring retakes.
+
+**Constructor**
+```cpp
+RetakeScheduler(std::unique_ptr<DatabaseManager> db_manager = nullptr)
+```
+- Initializes ROS2 node with name `g2_2025_retake_scheduler_node`
+- Sets up `DatabaseManager` (optional injection for testing)
+- Creates ROS2 action client for retake action communication
+- Initializes wall timer for periodic failing student checks
+
+**Core Functions**
+
+**`void check_failing_students()`**
+- Timer callback function executed periodically based on `retake_check_interval_sec`
+- Queries database for all failed course results
+- Iterates through failing students and initiates retake requests
+
+**`void send_retake_request(StudentCourse student_course_combo)`**
+- Creates retake action goal with student and course information
+- Sends asynchronous retake goal to `RetakeGradeDeterminator`
+
+**`void cancel_retake_request()`**
+- Cancels all active retake goals
+- Provides emergency stop functionality for retake processing
+
+**Action Client Callbacks**
+
+**`void request_response_callback(const rclcpp_action::ClientGoalHandle<RetakeAction>::SharedPtr &goal_handle)`**
+- Handles retake action server responses
+- Logs goal acceptance or rejection status
+- Provides feedback on retake request processing state
+
+**`void request_result_callback(const rclcpp_action::ClientGoalHandle<RetakeAction>::WrappedResult &result)`**
+- Processes final retake action results
+- Logs appropriate messages based on retake completion status
+
+**`void request_feedback_callback(rclcpp_action::ClientGoalHandle<RetakeAction>::SharedPtr goal_handle, const std::shared_ptr<const RetakeAction::Feedback> feedback)`**

doc/architecture/nodes/WheelDataSimulator.md

@@ -1,64 +0,0 @@
-# WheelDataSimulator (`assignments::three::wheel_data_simulator_node`)
-
-The `WheelDataSimulator` node generates simulated wheel encoder/velocity data (`std_msgs/msg/Float64MultiArray`) based on configurable time-varying intervals. It publishes wheel values for a 4-wheel robot configuration that can follow constant, linear, or quadratic trajectories over time.
-
-## Implementation Details
-
-**Parameters**
-
-| Parameter | Type | Default | Description |
-|-----------|------|---------|-------------|
-| `publish_rate` | double | 10.0 | Publishing frequency in Hz |
-| `max_intervals` | int | 4 | Maximum number of intervals per wheel |
-| `<wheel>.num_intervals` | int | 0 | Number of intervals for each wheel |
-| `<wheel>.interval_<n>.*` | various | - | Interval configuration (see Simulator) |
-
-**Wheels Configured:**
-- `wheel_fl` - Front Left wheel
-- `wheel_fr` - Front Right wheel
-- `wheel_rl` - Rear Left wheel
-- `wheel_rr` - Rear Right wheel
-
-**Constructor**
-```cpp
-DataSimulator()
-```
-- Initializes ROS2 node with name `wheel_data_simulator`
-- Creates `Simulator` instance for value generation
-- Creates publisher for `simulated_wheel_data` topic
-- Sets up timer for periodic publishing
-
-## Core Functionality
-
-**`void publish_wheel_data()`**
-- Timer callback invoked at the configured publish rate
-- Calculates elapsed time since node start
-- Queries `Simulator` for current values of all 4 wheels
-- Populates Float64MultiArray message with wheel values in order: [FL, FR, RL, RR]
-- Publishes message to topic
-
-## ROS2 Interface
-
-**Publications**
-- `simulated_wheel_data` (std_msgs/msg/Float64MultiArray)
-  - Publishes simulated wheel data at configured rate
-  - Array contains 4 values: [front_left, front_right, rear_left, rear_right]
-
-## Usage Example
-
-```bash
-ros2 run g2_2025_odometry_pkg wheel_data_simulator_node --ros-args \
-  -p publish_rate:=50.0 \
-  -p wheel_fl.num_intervals:=1 \
-  -p wheel_fl.interval_0.type:=linear \
-  -p wheel_fl.interval_0.t_start:=0.0 \
-  -p wheel_fl.interval_0.t_end:=10.0 \
-  -p wheel_fl.interval_0.y_start:=0.0 \
-  -p wheel_fl.interval_0.y_end:=5.0
-```
-
-## Dependencies
-
-- `rclcpp` - ROS2 C++ client library
-- `std_msgs` - Standard message types
-- `Simulator` - Internal simulation engine

doc/installation/installation.md

@@ -10,22 +10,6 @@
 - Colcon build tool
 - Docker compose
 
-### Paho MQTT library
-
-For this project the Paho MQTT library is needed, which can be built with the following commands:
-
-```bash
-git clone https://github.com/eclipse/paho.mqtt.cpp
-cd paho.mqtt.cpp
-git co v1.5.4
-
-git submodule init
-git submodule update
-
-cmake -Bbuild -H. -DPAHO_WITH_MQTT_C=ON -DPAHO_BUILD_EXAMPLES=ON
-sudo cmake --build build/ --target install
-```
-
 ### Clone the Repository
 
 ```bash
@@ -36,9 +20,11 @@ cd ros2-assignments
 ### Build the Workspace
 
 ```bash
-colcon build
+colcon build --packages-select g2_2025_assign1_interfaces_pkg
+source install/setup.bash
+colcon build --packages-select g2_2025_assign1_pkg
 ```
-Any parameters can be changed before building by editing the `imu_reader.launch.xml` in the launch folder
+Any parameters can be changed before building by editing the `grade_calculator.launch.xml` in the launch folder
 
 ### Source the Workspace
 
@@ -52,24 +38,8 @@ sudo docker-compose up
 ```
 You can configure specific database settings in the `docker-compose.yaml` in the root folder or the `config.toml` file in the `src/` folder
 
-### Start the IMU Reader program
+### Start the Grade calculator program
 ```bash
-# For Serial:
-ros2 launch g2_2025_imu_reader_pkg serial.launch.xml
-
-# For MQTT:
-ros2 launch g2_2025_imu_reader_pkg mqtt.launch.xml
+ros2 launch g2_2025_assign1_pkg grade_calculator.launch.xml
 ```
-To change parameters when using the launch file it will need to be edited in the `src/g2_2025_imu_reader_pkg/launch` folder. All parameters are already added to this document and thus only the values will need to be changed
-
-### Use the Lifecycle Node
-
-To setup the lifecycle node the following commands can be used. They must be used in this order.
-```bash
-ros2 lifecycle set /LifecycleManager configure
-ros2 lifecycle set /LifecycleManager cleanup
-ros2 lifecycle set /LifecycleManager activate
-ros2 lifecycle set /LifecycleManager deactivate
-ros2 lifecycle set /LifecycleManager shutdown
-```
-![img](https://design.ros2.org/img/node_lifecycle/life_cycle_sm.png)
+To change parameters when using the launch file it will need to be edited in the `src/g2_2025_assign1_pkg/launch` folder. All parameters are already added to this document and thus only the values will need to be changed

doc/tests/ConfigManager.md

@@ -1,6 +1,6 @@
 # Config Manager Unit Tests
 
-Unit tests for `ConfigManager` are implemented in `src/g2_2025_imu_reader_pkg/test/ConfigManager.test.cpp` using Google Test and ROS2 test utilities. The tests use temporary TOML files to validate configuration loading and parsing functionality.
+Unit tests for `ConfigManager` are implemented in `src/g2_2025_assign1_pkg/test/ConfigManager.test.cpp` using Google Test and ROS2 test utilities. The tests use temporary TOML files to validate configuration loading and parsing functionality.
 
 ## Test Cases
 
@@ -61,7 +61,7 @@ Unit tests for `ConfigManager` are implemented in `src/g2_2025_imu_reader_pkg/te
   [database]
   host = "localhost"
   port = 5432
-  dbname = "imu_data"
+  dbname = "grades"
   user = "postgres"
   password = "postgres"
   ```

doc/tests/DatabaseManager.md

@@ -1,6 +1,6 @@
 # Database Manager Unit Tests
 
-Unit tests for `DatabaseManager` are implemented in `src/g2_2025_imu_reader_pkg/test/DatabaseManager.test.cpp` using Google Test and ROS2 test utilities. The tests are designed to work reliably whether a database connection is available or not, focusing on error handling and method behavior validation.
+Unit tests for `DatabaseManager` are implemented in `src/g2_2025_assign1_pkg/test/DatabaseManager.test.cpp` using Google Test and ROS2 test utilities. The tests are designed to work reliably whether a database connection is available or not, focusing on error handling and method behavior validation.
 
 ## Test Cases
 
@@ -18,16 +18,46 @@ Unit tests for `DatabaseManager` are implemented in `src/g2_2025_imu_reader_pkg/
 - **Test Action:** Call `is_connected()` method
 - **Expected Result:** Returns either `true` or `false` (no crashes or invalid states)
 
-### 3. StoreIMUDataWhenNotConnected
+### 3. QueuePendingCombinationsTest
 
-**Description:** Verifies that storing IMU data without an active database connection fails gracefully.
+**Description:** Verifies retrieval of pending student-course combinations that need exam results.
 
-- **Test Action:** Call `store_imu_data(linear_x, linear_y, linear_z, ang_x, ang_y, ang_z)` without an active DB connection
-- **Expected Result:** Returns `false` and does not throw — method must check connection status before DB operations
+- **Test Action:** Call `queue_pending_combinations()`
+- **Expected Result:** Returns valid vector (empty if no database connection, populated if connected)
 
-### 4. CreateTablesNoCrash
+### 4. StoreExamResultTest
 
-**Description:** Verifies calling `create_tables()` without an active connection is safe.
+**Description:** Tests exam result storage with graceful handling of connection states.
 
-- **Test Action:** Call `create_tables()` on a manager that is not connected
-- **Expected Result:** No exception thrown; the function should be a no-op when no DB connection exists
+- **Test Action:**
+  - Student: `"TestStudent"`
+  - Course: `"TestCourse"`
+  - Grade: `85`
+- **Expected Result:** Returns `false` if no connection, `true` if connected and successful
+
+### 5. EnrollStudentTest
+
+**Description:** Tests student enrollment into courses.
+
+- **Test Action:**
+  - StudentCourse object with test data
+- **Expected Result:** Returns `false` if no connection, `true` if connected and successful
+
+### 6. GetFinalGradeTest
+
+**Description:** Tests final grade retrieval for non-existent student-course combinations.
+
+- **Test Action:**
+  - Student: `"NonExistentStudent"`
+  - Course: `"NonExistentCourse"`
+- **Expected Result:** Returns `-1` (no results found or no connection)
+
+### 7. StoreFinalResultTest
+
+**Description:** Tests storing calculated final course results.
+
+- **Test Action:**
+  - StudentCourse object
+  - Exam count: `3`
+  - Final grade: `75`
+- **Expected Result:** Returns `false` if no connection, `true` if connected and successful

doc/tests/ExamResultGenerator.md

@@ -0,0 +1,62 @@
+# Exam Result Generator Node Unit Tests
+
+Unit tests for `ExamResultGenerator` are implemented in `src/g2_2025_assign1_pkg/test/ExamResultGenerator.test.cpp` using Google Test and ROS2 test utilities. The tests use a test subscriber node to capture published messages and validate node behavior.
+
+## Test Cases
+
+### 1. ConstructorTest
+
+**Description:** Verifies that ExamResultGenerator can be created without crashing and proper initialization occurs.
+
+- **Test Action:** Create ExamResultGenerator node instance
+- **Expected Result:**
+  - Node created successfully without exceptions
+  - Node name set to `"exam_result_generator"`
+
+### 2. PublisherCreationTest
+
+**Description:** Verifies that the `exam_results` topic publisher is properly configured.
+
+- **Test Action:** Check topic names and types after node creation
+- **Expected Result:**
+  - `/exam_results` topic is published
+  - Topic uses `g2_2025_interfaces/msg/Exam` message type
+
+### 3. SubscriberCreationTest
+
+**Description:** Tests that the node subscribes to the `student_course_management` topic with correct message type.
+
+- **Test Action:** Check subscription topics and types
+- **Expected Result:**
+  - `/student_course_management` topic is subscribed
+  - Subscription uses `g2_2025_interfaces/msg/Student` message type
+
+### 4. StudentManagementMessageHandlingTest
+
+**Description:** Tests the node's ability to handle incoming student management messages without crashing.
+
+- **Test Action:**
+  - Publish student management message:
+    - Student: `"Test Student"`
+    - Course: `"Test Course"`
+- **Expected Result:** Message processed without crashes
+
+### 5. MultipleStudentMessagesTest
+
+**Description:** Validates handling of multiple rapid student management messages for robustness testing.
+
+- **Test Action:**
+  - Send multiple messages with different student-course combinations
+  - Students: `["Alice", "Bob", "Charlie"]`
+  - Courses: `["Math", "Physics", "Chemistry"]`
+- **Expected Result:** All messages processed without crashes or memory issues
+
+### 6. ExamMessageValidationTest
+
+**Description:** Captures and validates published exam result messages for correct content and format.
+
+- **Test Action:** Listen for published exam result messages over 6 seconds
+- **Expected Result:**
+  - Published grades are within range `[10, 100]`
+  - Course names are not empty
+  - Message format is correct

doc/tests/FinalGradeDeterminator.md

@@ -0,0 +1,52 @@
+# Final Grade Determintator Node Unit Tests
+
+Unit tests for `FinalGradeDeterminator` are implemented in `src/g2_2025_assign1_pkg/test/FinalGradeDeterminator.test.cpp` using Google Test and ROS2 test utilities. The tests use a mock database manager and a mock grade calculator service to simulate the node's interactions.
+
+## Test Cases
+
+### 1. ConstructorTest
+
+**Description:** Verifies that the node can be constructed without errors.
+
+- **Input:** Construct a `FinalGradeDeterminator` node.
+- **Expected Output:** No exceptions are thrown. The node is created successfully.
+
+### 2. ExamCollectionTest
+
+**Description:** Sends the required number of exam results and checks that a grade calculation request is triggered, a student message is published, and the results are stored.
+
+- **Input:**
+	- Student: `"Test Student"`
+	- Course: `"Test Course"`
+	- Grades published: `[80, 85, 90, 75, 95]` (5 exam results, which is the default required amount)
+- **Expected Output:**
+	- A grade calculation service request is made with the correct student, course, and grades.
+	- A student message is published with the correct student and course.
+	- The final grade is calculated as the average: (80 + 85 + 90 + 75 + 95) / 5 = 85.
+
+### 3. PartialExamCollectionTest
+
+**Description:** Sends fewer than the required number of exam results and checks that no grade calculation or student message occurs.
+
+- **Input:**
+	- Student: `"Test Student"`
+	- Course: `"Test Course"`
+	- Grades published: `[80, 85, 90]` (only 3 exam results, less than required)
+- **Expected Output:**
+	- No grade calculation service request is made.
+	- No student message is published.
+
+### 4. MultipleStudentsTest
+
+**Description:** Simulates multiple students submitting exam results and verifies that each student triggers independent grade calculation and messaging.
+
+- **Input:**
+	- Students: `"Alice"`, `"Bob"`
+	- Course: `"Test Course"`
+	- Each student receives grades: `[80, 85, 90, 75, 95]` (5 exam results per student)
+- **Expected Output:**
+	- Two grade calculation service requests are made, one for each student, with the correct grades.
+	- Two student messages are published, one for each student.
+	- The final grade for each student is calculated as the average: (80 + 85 + 90 + 75 + 95) / 5 = 85.
+
+These tests ensure that the node correctly collects exam results, triggers grade calculation at the right time, publishes the appropriate messages, and interacts with the database as expected.

doc/tests/GradeCalculator.md

@@ -0,0 +1,56 @@
+# Grade Calculator Node Unit Tests
+
+Unit tests for `GradeCalculator` are implemented in `src/g2_2025_assign1_pkg/test/GradeCalculator.test.cpp` using Google Test and ROS2 test utilities. The tests use a client to call the grade calculation service and verify the results.
+
+## Test Cases
+
+### 1. NormalAverage
+
+**Description:** Verifies that the service returns the average of the provided grades for a normal student name.
+
+- **Input:**
+	- Student: `"Alice"`
+	- Grades: `[80, 90, 70]`
+- **Expected Output:**
+	- Result: `80` (average of 80, 90, 70)
+
+### 2. WesselBonus
+
+**Description:** Checks that the student name "Wessel" (case-insensitive) receives a 10-point bonus, and the result is clamped to 100 if necessary.
+
+- **Input:**
+	- Student: `"Wessel"`
+	- Grades: `[80, 90, 70]`
+- **Expected Output:**
+	- Result: `90` (average 80 + 10 bonus)
+
+#### 3. wesselBonus
+
+**Description:** Checks that the bonus logic is case-insensitive for the student name "wessel".
+
+- **Input:**
+	- Student: `"wessel"`
+	- Grades: `[80, 90, 70]`
+- **Expected Output:**
+	- Result: `90` (average 80 + 10 bonus)
+
+#### 4. GradeTooHigh
+
+**Description:** Ensures that the grade is clamped to a maximum of 100, even after applying the bonus.
+
+- **Input:**
+	- Student: `"Wessel"`
+	- Grades: `[100, 100, 100]`
+- **Expected Output:**
+	- Result: `100` (average 100 + 10 bonus, clamped to 100)
+
+#### 5. GradeTooLow
+
+**Description:** Ensures that the grade is clamped to a minimum of 10.
+
+- **Input:**
+	- Student: `"Alice"`
+	- Grades: `[0, 0, 0]`
+- **Expected Output:**
+	- Result: `10` (average 0, clamped to 10)
+

doc/tests/IMUDataSimulator.md

@@ -1,67 +0,0 @@
-# IMU Data Simulator Unit Tests
-
-Unit tests for the `DataSimulator` (IMU) node are implemented in `src/g2_2025_odometry_pkg/test/test_imu_simulator.cpp` using Google Test and ROS2 test utilities. The tests validate node initialization, message publishing, and data correctness.
-
-## Test Cases
-
-### 1. NodeInitialization
-
-**Description:** Verifies that the DataSimulator node can be created without errors.
-
-- **Test Action:** Create DataSimulator instance
-- **Expected Result:** No exceptions thrown during construction
-
-### 2. MessagePublishing
-
-**Description:** Tests that IMU messages are published on the correct topic.
-
-- **Test Action:**
-  - Create subscription to `simulated_imu_data` topic
-  - Create DataSimulator node
-  - Spin both nodes for a short period
-- **Expected Result:** At least one `sensor_msgs/msg/Imu` message is received
-
-### 3. MessageFrameId
-
-**Description:** Verifies that published IMU messages have the correct frame_id.
-
-- **Test Action:**
-  - Subscribe to `simulated_imu_data`
-  - Receive a message
-- **Expected Result:** `header.frame_id` equals `"imu_link"`
-
-### 4. LinearAccelerationValues
-
-**Description:** Tests that linear acceleration values are valid (finite numbers).
-
-- **Test Action:**
-  - Subscribe and receive IMU message
-  - Check linear_acceleration fields
-- **Expected Result:**
-  - `linear_acceleration.x` is finite
-  - `linear_acceleration.y` is finite
-  - `linear_acceleration.z` is finite
-
-### 5. AngularVelocityValues
-
-**Description:** Tests that angular velocity values are valid (finite numbers).
-
-- **Test Action:**
-  - Subscribe and receive IMU message
-  - Check angular_velocity fields
-- **Expected Result:**
-  - `angular_velocity.x` is finite
-  - `angular_velocity.y` is finite
-  - `angular_velocity.z` is finite
-
-## Test Infrastructure
-
-The test class `IMUSimulatorTest` provides:
-- Static `SetUpTestSuite()` and `TearDownTestSuite()` for ROS2 init/shutdown
-- Helper method `setupBasicIMUParams()` for setting up default test parameters
-
-## ROS2 Topics Used
-
-| Topic | Message Type | Direction |
-|-------|--------------|-----------|
-| `simulated_imu_data` | sensor_msgs/msg/Imu | Published by node under test |

doc/tests/IMUDatabaseWriter.md

@@ -1,18 +0,0 @@
-# IMU Database Writer Unit Tests
-
-Unit tests for `IMUDatabaseWriter` are implemented in `src/g2_2025_imu_reader_pkg/test/IMUDatabaseWriter.test.cpp` using Google Test and ROS2 test utilities. These tests validate that the node subscribes to the `imu_data` topic, receives IMU messages, and forwards parsed values to the `DatabaseManager` interface. Tests use dependency injection with a mock `DatabaseManager` to avoid requiring a real database connection.
-
-## Test Cases
-
-### 1. ConstructorTest
-
-**Description:** Verifies that `IMUDatabaseWriter` can be constructed.
-
-- **Test Action:** Create `IMUDatabaseWriter` node with a `MockDatabaseManager`
-- **Expected Result:** Node instance created successfully without exceptions
-
-### 2. ReceivesAndForwardsIMU
-
-**Description:** Tests that the node receives IMU messages on the `imu_data` topic and calls `store_imu_data(...)` on the injected database manager.
-
-- **Expected Result:** Mock's `called_` flag is set to `true`, confirming the node forwarded the IMU data to the database manager

doc/tests/IntegrationTest.md

@@ -0,0 +1,151 @@
+# Integration Test
+
+Tests the whole integrated system `nodes` connected with each other, with supervisory control and visualization of the database. It tests all major components working together: exam result generation, calculation, database usage, and retake handling.
+
+For validation and verification of database data the databse viewer Dbeaver can be used.
+
+## Test Input Data
+
+**Student Enrollments:**
+
+- `"Wessel", "ROS2"`
+- `"Vincent", "ROS2"`
+- `"Mohammed", "Differentieren"`
+- `"Tilmann", "Differentieren"`
+
+## Test workflow
+
+### 1. Complete Grade Processing Pipeline
+
+**Description**: Tests the full workflow from student enrollment through exam generation to final grade calculation.
+
+**Steps:**
+
+1. **Setup Phase**
+   - Clear the database via `docker container prune` or by deleting the tables in dbeaver.
+   - Start the databse in a standalone terminal via the command `sudo docker compose up`.
+   - Verify database connection.
+   - Initialize all system nodes (ExamResultGenerator, FinalGradeDeterminator, GradeCalculator) after building tha package and starting it via the `grade_calculator.launch.xml`.
+
+2. **Exam Generation Phase**
+   - ExamResultGenerator publishes Exam messages per student-course pair to table `exam_results` topic.
+   - Verify exam results have valid grades (10-100 range).
+   - Confirm proper timestamp and student/course name matching.
+
+3. **Grade Collection Phase**
+   - FinalGradeDeterminator collects exam results for each student-course combination.
+   - Monitor collection count reaches threshold (5 exams per student-course by default) for each student.
+
+4. **Grade Calculation Phase**
+   - FinalGradeDeterminator calls GradeCalculator service when threshold reached.
+   - Service calculates average grade.
+
+5. **Persistence and Notification Phase**
+   - Final grades stored in database with proper timestamps.
+   - verify that final_grade_determinator has sent a de-enroll request via student_course_managment to exam_result_generator.
+   - exam_result_generator should now prints `removed from queue`.
+   - Verify final grade is within valid bounds (10-100) in table `final_course_results`.
+
+**Expected Results:**
+
+```text
+Student: Wessel, Course: ROS2
+- 5 exam results generated (random grades 10-100)
+- Avrage final grade calculated
+- Grade stored in database
+
+
+Student: Vincent, Course: ROS2
+- 5 exam results generated (random grades 10-100)
+- Avrage final grade calculated
+- Grade stored in database
+
+
+Student: Mohammed, Course: Differentieren
+- 5 exam results generated (random grades 10-100)
+- Avrage final grade calculated
+- Grade stored in database
+
+
+Student: Tilmann, Course: Differentieren
+- 5 exam results generated (random grades 10-100)
+- Avrage final grade calculated
+- Grade stored in database
+```
+
+### 2. Retake Process Integration
+
+**Description**: Tests the retake workflow for students who need to retake exams.
+
+**Setup:**
+
+no setup required, this starts immediately after `final_grade_diterminator` is done after getting the first grades for the students.
+
+**Steps:**
+
+1. **Varify Retake Schedualer is started**
+   - Verify in the terminal the schedualer starts the retake process.
+
+2. **Retake Request Phase**
+   - RetakeScheduler checks the database for failing students
+   - Schedules retake exams with `retake_grade_determinator`
+
+3. **Retake Execution Phase**
+   - Generate retake exam results
+   - `retake_grade_determinator` processes retake grades and sends them to the calcculator.
+   - `retake_grade_determinator` finaly stores the calculated result in the database.
+
+4. **Final Grade Update**
+   - Verify grade history preservation
+   - Confirm final grade reflects retake performance
+
+**Failing student Expected Retake Results:**
+
+```text
+Student: student, Course: course
+- 5 exam results generated (random grades 10-100)
+- Avrage final grade calculated
+- Grade stored in database
+- Retake_done checkmark
+- Is_retake checkmark
+```
+
+## Success Criteria
+
+### Functional Requirements
+
+ All student enrollments processed correctly
+ Exam results generated within valid range (10-100)
+ Grade collection reaches configured thresholds
+ Final grades calculated using proper business logic
+ Database persistence works reliably
+ Retake process functions correctly when needed
+ All ROS2 communication protocols working
+
+## Test Execution Commands
+
+```bash
+# 1. enter the ros2 assignment folder
+cd /YOUR/PATH/HERE/ros2-assignment
+
+# 2. Build the packages and source the enviroment
+colcon build && source install/setup.bash
+
+# 3. clear and Start database (if not running) in stand alone terminal
+sudo docker container prune && sudo docker compose up
+
+# 4. Launch all system nodes
+ros2 launch g2_2025_assign1_pkg grade_calculator.launch.xml
+
+# 6. Monitor database state
+By opening dbeaver and connecting to the database "grades".
+Password: postgres
+```
+
+## Verification
+
+### Database Validation
+
+- **Student Records**: Verify all students are enrolled correctly
+- **Exam Results**: Confirm all exam data is good
+- **Final Grades**: Validate calculated grades and timestamps

doc/tests/IntegrationTests.md

@@ -1,284 +0,0 @@
-# IMU System Integration Tests
-
-This document describes integration tests for the IMU data pipeline (IMU reader ESP32, Lifecycle MITM node, Database writer node).
-These tests will verify end-to-end functionality from ESP32 sensor data to database storage.
-
-## Test Overview
-
-The integration tests validate the complete flow through the main components:
-1. ESP32 MPU6886 Sensor - Data fetching and transmission (MQTT or Serial)
-2. ROS2 Lifecycle Node - Message reception from ESP and forwarding to database writer
-3. IMU Database Writer Node - Database storage
-
-## Test Environment Setup
-
-### Prerequisites
-
-- ESP32 with MPU6886 sensor configured and flashed
-- PostgreSQL database running (can be ran using dockerfile documented in the [README](/README.md))
-- ROS2 workspace built and sourced
-- if testing MQTT mode, MQTT broker running
-- if testing Serial mode, Serial port access
-
-### Configuration Files
-
-- `src/config.toml` - Database connection parameters
-- `IMU/sdkconfig` - Serial/MQTT mode selection and network settings
-
----
-
-## Integration Test Cases
-
-### Test 1: Database Writer Persistence Verification
-
-> Verify that the Database Writer node correctly saves data to the PostgreSQL database when
-> IMU messages are received.
-
-#### Test Setup
-
-1. Start PostgreSQL database (docker compose up)
-2. Verify database connection, if incorrect change settings settings in `src/config.toml`
-3. Clear or note the current state of the IMU data table
-4. Launch the Database Writer node:
-   ```bash
-   ros2 run g2_2025_imu_reader_pkg g2_2025_imu_database_writer_node
-   ```
-
-#### Test Procedure
-
-1. Query the database for initial row count
-   ```sql
-   SELECT COUNT(*) FROM imu_data;
-   ```
-
-2. Use ROS2 CLI to publish IMU data
-   ```bash
-   ros2 topic pub --once /imu_data sensor_msgs/msg/Imu "{
-     linear_acceleration: {x: 0.5, y: 0.6, z: 9.8},
-     angular_velocity: {x: 0.1, y: 0.2, z: 0.3}
-   }"
-   ```
-
-3. Query the database for new entries
-   ```sql
-   SELECT * FROM imu_data ORDER BY timestamp DESC LIMIT 1;
-   ```
-
-4. Send 10 messages with varying data
-   ```bash
-   for i in {1..10}; do
-     ros2 topic pub --once /imu_data sensor_msgs/msg/Imu "{
-       linear_acceleration: {x: $(echo "scale=2; $i * 0.1" | bc), y: 0.0, z: 9.8},
-       angular_velocity: {x: 0.0, y: 0.0, z: 0.0}
-     }"
-     sleep 0.5
-   done
-   ```
-
-5. Confirm all 10 messages were persisted
-   ```sql
-   SELECT COUNT(*) FROM imu_data WHERE timestamp > (NOW() - INTERVAL '1 minute');
-   ```
-
-#### Expected Results
-
-- [ ] Each published message creates one database row
-- [ ] Linear acceleration values (x, y, z) match published data
-- [ ] Angular velocity values (x, y, z) match published data
-- [ ] Timestamps are automatically generated and sequential
-- [ ] No data loss occurs
-
-### Test 2: Lifecycle Node Message Forwarding
-
-> Verify that the Lifecycle Node correctly receives IMU data from either Serial or MQTT sources and
-> forwards it to the `imu_data` topic for consumption by the Database Writer.
-
-#### Test Setup
-
-1. Ensure ROS2 environment is sourced
-2. Launch the Lifecycle Node and Database Writer Node:
-   ```bash
-   ros2 run g2_2025_imu_reader_pkg g2_2025_lifecycle_node
-   ros2 run g2_2025_imu_reader_pkg g2_2025_imu_database_writer_node
-   ```
-4. Monitor the `imu_data` topic:
-   ```bash
-   ros2 topic echo /imu_data
-   ```
-
-#### Test Procedure - Serial Mode
-
-1. Configure ESP32 for Serial Output:
-   - Ensure `CONFIG_ENV_MQTT_ENABLED` is not defined in ESP32 sdkconfig
-   - Flash ESP32 with serial configuration
-
-2. Connect ESP32 via Serial:
-   - Connect ESP32 to computer via USB
-   - Identify serial port (e.g., `/dev/ttyUSB0` on Linux)
-   - Configure lifecycle node to read from this serial port
-
-3. Verify Data Flow:
-   - Observe lifecycle node logs for incoming serial data
-   - Confirm `ros2 topic echo /imu_data` displays messages
-   - Verify message fields match ESP32 output:
-     - `linear_acceleration.x/y/z` matches `accel.x/y/z`
-     - `angular_velocity.x/y/z` matches `gyro.x/y/z`
-
-4. Verify Database storage:
-   - Check database for new entries
-   - Confirm values match ESP32 sensor readings
-
-#### Test Procedure - MQTT Mode
-
-1. Start MQTT Broker:
-   ```bash
-   mosquitto -v
-   ```
-
-2. **Configure ESP32 for MQTT Output**:
-   - Enable `CONFIG_ENV_MQTT_ENABLED` in ESP32 sdkconfig
-   - Configure MQTT broker URI (`mqtt://192.168.1.100:1883`)
-   - Set MQTT topic (`CONFIG_MQTT_TOPIC = "imu/data"`)
-   - Configure WiFi credentials
-   - Flash ESP32 with MQTT configuration
-
-3. Verify MQTT Publishing:
-   - Subscribe to MQTT topic to confirm ESP32 is publishing:
-     ```bash
-     mosquitto_sub -h localhost -t "imu/data" -v
-     ```
-   - Expected MQTT payload format:
-     ```json
-     {"accel":{"x":0.123,"y":0.456,"z":9.800},"gyro":{"x":0.012,"y":0.023,"z":0.034},"Temp":25.50}
-     ```
-
-4. Configure Lifecycle Node for MQTT:
-   - Set lifecycle node to subscribe to MQTT broker and topic
-   - Restart lifecycle node with MQTT configuration
-
-5. Verify Data Flow:
-   - Observe lifecycle node logs for incoming MQTT messages
-   - Confirm `ros2 topic echo /imu_data` displays messages
-
-6. Verify Database storage:
-   - Check database for continuously arriving data
-   - Confirm timestamps are recent and sequential
-
-#### Expected Results
-
-**Serial Mode:**
-- [ ] Lifecycle node successfully reads JSON-formatted messages from serial port
-- [ ] Messages are parsed and converted to `sensor_msgs/msg/Imu` format
-- [ ] All IMU data fields are correctly mapped
-- [ ] Messages are published to `/imu_data` topic
-- [ ] Database writer receives and persists data
-
-**MQTT Mode:**
-- [ ] Lifecycle node successfully subscribes to MQTT broker
-- [ ] MQTT messages are received and parsed
-- [ ] Messages are converted to `sensor_msgs/msg/Imu` format
-- [ ] All IMU data fields are correctly mapped
-- [ ] Messages are published to `/imu_data`
-- [ ] Database writer receives and persists data
-
-### Test 3: ESP32 Data Format Validation
-> Verify that the ESP32 correctly formats and transmits IMU data in both Serial
-> and MQTT modes according to the expected JSON schema.
-
-#### Test Setup
-
-1. ESP32 with MPU6886 sensor properly wired and powered
-2. IMU sensor calibrated (100 samples for gyro and accel)
-3. Serial terminal or MQTT subscriber ready to capture output
-
-#### Data Quality Checks
-
-- [ ] Accelerometer Z-axis reads ~9.8 (m/s)^2 when device is stationary and level
-- [ ] Gyroscope values near zero when device is stationary
-- [ ] Temperature reading is within expected range
-- [ ] No NaN or Inf values in output
-- [ ] Calibration offsets are properly applied
-
----
-
-## End-to-End Integration Test
-
-**Objective**: Validate complete system integration from ESP32 sensor to database persistence.
-
-### Test Setup
-
-1. Clean database state (truncate IMU data table)
-2. Start PostgreSQL database
-3. Start MQTT broker (for MQTT test variant)
-4. Launch all ROS2 nodes:
-   - Lifecycle node
-   - Database writer node
-5. Power on and connect ESP32
-
-### Test Procedure
-
-1. System Initialization:
-   - Verify all nodes are running and healthy
-   - Check lifecycle node is connected to data source (Serial/MQTT)
-   - Confirm database writer node is subscribed to `/imu_data`
-
-2. Data Flow Verification:
-   - Let system run for 2 minutes
-   - Monitor ROS2 topics:
-     ```bash
-     ros2 topic hz /imu_data
-     ros2 topic bw /imu_data
-     ```
-
-3. **Database Query**:
-   ```sql
-   SELECT COUNT(*) FROM imu_data WHERE timestamp > (NOW() - INTERVAL '2 minutes');
-   SELECT
-     AVG(linear_accel_z) as avg_accel_z,
-     AVG(angular_vel_x) as avg_gyro_x,
-     MIN(timestamp) as first_sample,
-     MAX(timestamp) as last_sample
-   FROM imu_data
-   WHERE timestamp > (NOW() - INTERVAL '2 minutes');
-   ```
-
-4. Physical Movement Test:
-   - Pick up ESP32 and rotate it
-   - Observe changes in database values
-   - Verify accelerometer and gyroscope values change
-
-5. Stress Test:
-   - Let system run for 30 minutes
-   - Check for memory leaks or connection drops
-   - Verify continuous data storage
-
-### Expected Results
-
-- [ ] Data flows from ESP32 -> Lifecycle Node -> Database Writer -> PostgreSQL
-- [ ] Publishing rate at `/imu_data`
-- [ ] Database receives ~240 rows in 2 minutes
-- [ ] Average Z-axis acceleration is ~9.8 (m/s)^2 during stationary periods
-- [ ] Physical movements are reflected in database values
-- [ ] No data loss over extended operation (30 minutes)
-- [ ] All components remain stable without crashes
-
-## Test Execution Checklist
-
-### Pre-Test Verification
-- [ ] PostgreSQL database is running and accessible
-- [ ] Database schema is created (IMU data table exists)
-- [ ] ROS2 workspace is built and sourced
-- [ ] ESP32 firmware is flashed with correct configuration
-- [ ] MQTT broker is running
-- [ ] Serial port permissions are correct
-
-### During Test
-- [ ] Monitor node logs for errors or warnings
-- [ ] Check ROS2 topic publishing rates
-- [ ] Verify database connection remains active
-- [ ] Observe IMU data values
-
-### Post-Test Analysis
-- [ ] Review test results and logs
-- [ ] Document any failures or anomalies
-- [ ] Clean up test data if necessary

doc/tests/LifecycleManager.md

@@ -1,229 +0,0 @@
-# LifecycleManager Unit Tests
-
-Unit tests for `LifecycleManager` are implemented in `src/g2_2025_imu_reader_pkg/test/LifecycleManager.test.cpp` using Google Test and ROS2 lifecycle test utilities. The tests are designed to validate all lifecycle state transitions, parameter handling, and hardware integration without requiring actual hardware or MQTT broker connectivity.
-
-## Test Cases
-
-### 1. ConstructorTest
-
-**Description:** Verifies that LifecycleManager can be instantiated without crashing and parameters are correctly declared.
-
-- **Test Action:** Create LifecycleManager instance with default parameters
-- **Expected Result:** Instance created successfully; parameters `device_path`, `baudrate`, and `comm_t` are registered with their defaults
-
----
-
-### 2. ParameterDeclarationTest
-
-**Description:** Tests that all required parameters are declared during construction with correct default values.
-
-- **Test Action:**
-  - Create LifecycleManager
-  - Query parameters: `device_path`, `baudrate`, `comm_t`
-- **Expected Result:**
-  - `device_path` defaults to `"/dev/ttyUSB0"`
-  - `baudrate` defaults to `115200`
-  - `comm_t` defaults to `"serial"`
-
----
-
-### 3. ParameterRuntimeReadTest
-
-**Description:** Verifies parameters can be read at runtime and affect behavior.
-
-- **Test Action:**
-  - Set parameters via ROS2 parameter API: `device_path="/dev/ttyACM0"`, `comm_t="mqtt"`
-  - Verify LifecycleManager reads the updated values
-- **Expected Result:** Parameters are correctly read and stored in member variables
-
----
-
-### 4. InitialStateTest
-
-**Description:** Tests that the node starts in the `UNCONFIGURED` state.
-
-- **Test Action:** Create LifecycleManager and check lifecycle state
-- **Expected Result:** Node is in `UNCONFIGURED` state
-
----
-
-### 5. ConfigureSerialModeTest
-
-**Description:** Tests the `on_configure` callback in serial communication mode.
-
-- **Test Action:**
-  - Set `comm_t` parameter to `"serial"`
-  - Call `on_configure()` with valid device path (e.g., `/dev/null` for testing)
-- **Expected Result:**
-  - Transition succeeds
-  - Node moves to `INACTIVE` state
-  - `HardwareInterface::open_device()` is called with correct parameters
-
----
-
-### 6. ConfigureMQTTModeTest
-
-**Description:** Tests the `on_configure` callback in MQTT communication mode.
-
-- **Test Action:**
-  - Set `comm_t` parameter to `"mqtt"`
-  - Call `on_configure()`
-- **Expected Result:**
-  - Transition succeeds
-  - Node moves to `INACTIVE` state
-  - `HardwareInterface::mqtt_configure()` is called
-
----
-
-### 7. ConfigureSerialFailureTest
-
-**Description:** Tests graceful failure when serial device cannot be opened.
-
-- **Test Action:**
-  - Set `device_path` to non-existent path (e.g., `/dev/invalid_device`)
-  - Set `comm_t` to `"serial"`
-  - Call `on_configure()`
-- **Expected Result:**
-  - Transition handled gracefully (node doesn't crash)
-  - Error logging occurs
-
----
-
-### 8. DeactivateSerialModeTest
-
-**Description:** Tests the `on_deactivate` callback in serial communication mode.
-
-- **Test Action:**
-  - Configure to `INACTIVE` state in serial mode
-  - Call `on_deactivate()`
-- **Expected Result:**
-  - Transition handled gracefully
-  - Resources are properly released
-
----
-
-### 9. ResourceCleanupTest
-
-**Description:** Tests that all resources are properly cleaned up on deactivation and shutdown.
-
-- **Test Action:**
-  - Configure node with serial settings
-  - Let node go out of scope
-  - Verify no crashes or resource leaks
-- **Expected Result:**
-  - No memory leaks
-  - File descriptors are closed
-  - No segmentation faults on cleanup
-
----
-
-### 10. ErrorLoggingTest
-
-**Description:** Tests that error handling works during configuration attempts.
-
-- **Test Action:**
-  - Set invalid device path and attempt configuration
-  - Verify error is handled gracefully
-- **Expected Result:**
-  - Node doesn't crash on error
-  - Error logging occurs
-
----
-
-### 11. HardwareInterfaceIntegrationTest
-
-**Description:** Tests the complete integration between LifecycleManager and HardwareInterface.
-
-- **Test Action:**
-  - Create LifecycleManager instance
-  - Verify HardwareInterface instance is created and accessible
-  - Verify we can call HardwareInterface methods
-- **Expected Result:**
-  - HardwareInterface is properly initialized
-  - No segmentation faults when accessing interface methods
-
----
-
-### 12. DevicePathParameterTest
-
-**Description:** Tests that device_path parameter correctly controls serial device selection.
-
-- **Test Action:**
-  - Set `device_path` to `/dev/null`
-  - Call `on_configure()` in serial mode
-  - Verify correct device path is used
-- **Expected Result:**
-  - Configuration succeeds with correct device path
-
----
-
-### 13. BaudRateParameterTest
-
-**Description:** Tests that baudrate parameter is correctly configured.
-
-- **Test Action:**
-  - Set `baudrate` to valid value (e.g., 115200)
-  - Call `on_configure()` in serial mode
-- **Expected Result:**
-  - Correct baud rate is passed to the hardware interface
-
----
-
-### 14. ParameterUpdateBehaviorTest
-
-**Description:** Tests that parameter changes are respected across state transitions.
-
-- **Test Action:**
-  - Set `comm_t` to `"serial"`, configure
-  - Deactivate and transition back to UNCONFIGURED
-  - Change `comm_t` to `"mqtt"`
-  - Re-configure with new communication mode
-- **Expected Result:**
-  - Communication mode switches work correctly
-  - Parameter changes are respected
-
----
-
-## Test Organization
-
-Tests are organized into logical groups:
-
-1. **Construction & Initialization** (Tests 1-3): Basic object creation and parameter setup
-2. **State Transitions & Configuration** (Tests 4-7): Lifecycle callbacks and state validation
-3. **Parameter Validation** (Tests 12-13): Parameter binding and influence on behavior
-4. **Complete Sequences** (Test 14): Parameter switching across state transitions
-5. **Resource & Thread Safety** (Tests 8-9): Resource cleanup and safe deactivation
-6. **Error Handling & Integration** (Tests 10-11): Error resilience and component integration
-
----
-
-## Test Execution
-
-### Run All Tests
-
-```bash
-# From workspace root
-colcon test --packages-select g2_2025_imu_reader_pkg
-```
-
-### Run Specific Test Suite
-
-```bash
-# Run only LifecycleManager tests
-colcon test --packages-select g2_2025_imu_reader_pkg --ctest-args -R "LifecycleManager"
-```
-
-### Run with Verbose Output
-
-```bash
-colcon test --packages-select g2_2025_imu_reader_pkg --ctest-args --verbose
-```
-
-### Run Tests Directly
-
-```bash
-# From workspace root
-./build/g2_2025_imu_reader_pkg/g2_2025_imu_reader_pkg_test_lifecycle_manager
-```
-
----

doc/tests/RetakeGradeDeterminator.md

@@ -0,0 +1,70 @@
+# RetakeGradeDeterminator Node Unit Tests
+
+This document describes the unit tests for the `RetakeGradeDeterminator` ROS 2 node, as implemented in [`RetakeGradeDeterminator.test.cpp`](../../src/g2_2025_assign1_pkg/test/RetakeGradeDeterminator.test.cpp).
+
+## Test Cases
+
+### 1. ConstructorTest
+
+- **Purpose:**
+  Verifies that the `RetakeGradeDeterminator` can be constructed without throwing exceptions.
+- **Checks:**
+  - The node is created successfully and is not `nullptr`.
+
+### 2. PublisherCreationTest
+
+- **Purpose:**
+  Ensures that the node creates a publisher for the `student_course_management` topic.
+- **Checks:**
+  - The `/student_course_management` topic is present and uses the `Student` message type.
+
+### 3. SubscriberCreationTest
+
+- **Purpose:**
+  Ensures that the node subscribes to the `exam_results` topic.
+- **Checks:**
+  - The `/exam_results` topic is present and uses the `Exam` message type.
+
+### 4. ActionServerCreationTest
+
+- **Purpose:**
+  Verifies that the node creates an action server for the `retake_action`.
+- **Checks:**
+  - The action server is available and can be connected to by an action client.
+
+### 5. ServiceClientCreationTest
+
+- **Purpose:**
+  Ensures that the node creates a client for the `grade_calculator_service`.
+- **Checks:**
+  - The `/grade_calculator_service` is present in the node's service graph.
+
+### 6. ParameterTest
+
+- **Purpose:**
+  Confirms that the node's parameters are set to their expected default values.
+- **Checks:**
+  - The `grade_collection_amount` parameter defaults to `5`.
+
+### 7. ExamResultsIgnoredWhenRetakeNotAllowed
+
+- **Purpose:**
+  Ensures that exam results are ignored if a retake is not currently allowed.
+- **Checks:**
+  - No service requests are made when a retake is not in progress.
+
+### 8. RetakeActionGoalAcceptance
+
+- **Purpose:**
+  Verifies that the node accepts retake action goals and publishes the appropriate student enrollment message.
+- **Checks:**
+  - The retake goal is accepted.
+  - A `Student` message is published with the correct student and course names.
+
+### 9. PartialExamResultsCollection
+
+- **Purpose:**
+  Ensures that the node does not process or store results if not enough exam results have been collected during a retake.
+- **Checks:**
+  - No service requests are made.
+  - No results are stored in the database if the required number of exam results has not been reached.

doc/tests/RetakeScheduler.md

@@ -0,0 +1,50 @@
+# RetakeScheduler Node Unit Tests
+
+Unit tests for `RetakeScheduler` are implemented in `src/g2_2025_assign1_pkg/test/RetakeScheduler.test.cpp`
+The unit tests are written using Google Test and ROS 2 test utilities. They utilize clients to interact
+with the RetakeScheduler node's services and actions, verifying correct behavior and expected outcomes.
+
+## Test Cases
+
+### 1. ConstructorTest
+
+- **Purpose:**
+  Verifies that the `RetakeScheduler` can be constructed without throwing exceptions.
+- **Checks:**
+  - The node is created successfully and is not `nullptr`.
+
+
+### 2. ActionClientCreationTest
+
+- **Purpose:**
+  Ensures that the `RetakeScheduler` node creates the expected action client services for the retake action.
+- **Checks:**
+  - At least one of the retake action client services (`/retake_action/_action/cancel_goal`, `/retake_action/_action/get_result`, `/retake_action/_action/send_goal`) is present in the node's service graph.
+
+
+### 3. ParameterTest
+
+- **Purpose:**
+  Confirms that the node's parameters are set to their expected default values.
+- **Checks:**
+  - The `retake_check_interval_sec` parameter defaults to `120`.
+
+
+### 4. ActionClientAllServicesPresentTest
+
+- **Purpose:**
+  Verifies that all required action client services for the retake action are available.
+- **Checks:**
+  - The following services are present:
+    - `/retake_action/_action/cancel_goal`
+    - `/retake_action/_action/get_result`
+    - `/retake_action/_action/send_goal`
+
+
+### 5. ConstructorWithNullDatabaseManager
+
+- **Purpose:**
+  Tests the node's behavior when constructed with a `nullptr` database manager.
+- **Checks:**
+  - The node can be constructed without throwing, even if the database manager is `nullptr`.
+

doc/tests/Simulator.md

@@ -1,98 +0,0 @@
-# Simulator Unit Tests
-
-Unit tests for the `Simulator` class are implemented in `src/g2_2025_odometry_pkg/test/test_simulator.cpp` using Google Test and ROS2 test utilities. The tests validate interval-based value generation with different interpolation types.
-
-## Test Cases
-
-### 1. ConstantInterval
-
-**Description:** Verifies constant interpolation returns the same value throughout the interval.
-
-- **Test Configuration:**
-  - Single interval: t=[0, 10], y_start=5.0
-  - Type: constant
-- **Expected Result:**
-  - Value is 5.0 at t=0, t=5, t=10
-  - Value holds at 5.0 after interval (t=15)
-
-### 2. LinearInterval
-
-**Description:** Tests linear interpolation between start and end values.
-
-- **Test Configuration:**
-  - Single interval: t=[0, 10], y_start=0.0, y_end=10.0
-  - Type: linear
-- **Expected Result:**
-  - Value is 0.0 at t=0
-  - Value is 5.0 at t=5
-  - Value is 10.0 at t=10
-  - Value holds at 10.0 after interval (t=15)
-
-### 3. QuadraticInterval
-
-**Description:** Tests quadratic (Lagrange) interpolation through 3 points.
-
-- **Test Configuration:**
-  - Single interval: t=[0, 10], y_start=0.0, y_end=0.0, t_mid=5.0, y_mid=10.0
-  - Type: quadratic
-- **Expected Result:**
-  - Value is 0.0 at t=0
-  - Value is 10.0 at t=5 (peak)
-  - Value is 0.0 at t=10
-  - Value holds at 0.0 after interval (t=15)
-
-### 4. MultipleIntervals
-
-**Description:** Tests behavior with multiple non-overlapping intervals and gaps.
-
-- **Test Configuration:**
-  - Interval 0: t=[0, 5], constant 5.0
-  - Interval 1: t=[10, 15], constant 10.0
-  - Gap between t=5 and t=10
-- **Expected Result:**
-  - Value is 5.0 at t=2.5 (first interval)
-  - Value holds at 5.0 in gap (t=7.5)
-  - Value is 10.0 at t=12.5 (second interval)
-  - Value holds at 10.0 after all intervals (t=20)
-
-### 5. ValueBeforeIntervals
-
-**Description:** Tests behavior when querying time before any interval starts.
-
-- **Test Configuration:**
-  - Single interval: t=[10, 20]
-- **Expected Result:**
-  - Value is 0.0 at t=5 (before interval starts)
-
-### 6. NonExistentChannel
-
-**Description:** Tests graceful handling of queries for unconfigured channels.
-
-- **Test Action:** Query `get_object_value("nonexistent_channel", 5.0)`
-- **Expected Result:** Returns 0.0
-
-### 7. OverlappingIntervalsThrowsException
-
-**Description:** Verifies that overlapping intervals are detected and rejected.
-
-- **Test Configuration:**
-  - Interval 0: t=[0, 10]
-  - Interval 1: t=[5, 15] (overlaps)
-- **Expected Result:** Constructor throws `std::runtime_error`
-
-### 8. MaxIntervalsLimit
-
-**Description:** Tests that `max_intervals` parameter limits loaded intervals.
-
-- **Test Configuration:**
-  - max_intervals=2
-  - num_intervals=3 (defines 3 intervals)
-- **Expected Result:**
-  - Only first 2 intervals are loaded
-  - Third interval values default to holding second interval's end value
-
-## Test Infrastructure
-
-The test class `SimulatorTest` provides:
-- Static `SetUpTestSuite()` and `TearDownTestSuite()` for ROS2 init/shutdown
-- Helper method `createNodeWithParams()` for creating nodes with parameter overrides

doc/tests/WheelDataSimulator.md

@@ -1,73 +0,0 @@
-# Wheel Data Simulator Unit Tests
-
-Unit tests for the `DataSimulator` (Wheel) node are implemented in `src/g2_2025_odometry_pkg/test/test_wheel_simulator.cpp` using Google Test and ROS2 test utilities. The tests validate node initialization, message publishing, array structure, and data correctness.
-
-## Test Cases
-
-### 1. NodeInitialization
-
-**Description:** Verifies that the Wheel DataSimulator node can be created without errors.
-
-- **Test Action:** Create DataSimulator instance
-- **Expected Result:** No exceptions thrown during construction
-
-### 2. WheelDataPublishing
-
-**Description:** Tests that wheel data messages are published on the correct topic.
-
-- **Test Action:**
-  - Create subscription to `simulated_wheel_data` topic
-  - Create DataSimulator node
-  - Spin both nodes for a short period
-- **Expected Result:** At least one `std_msgs/msg/Float64MultiArray` message is received
-
-### 3. WheelDataArraySize
-
-**Description:** Verifies that the published array contains the correct number of wheel values.
-
-- **Test Action:**
-  - Subscribe to `simulated_wheel_data`
-  - Receive a message
-  - Check array size
-- **Expected Result:** `data.size()` equals 4 (FL, FR, RL, RR)
-
-### 4. ValidVelocityValues
-
-**Description:** Tests that all wheel velocity values are valid (finite numbers).
-
-- **Test Action:**
-  - Subscribe and receive wheel data message
-  - Check each value in the array
-- **Expected Result:** All 4 values are finite numbers
-
-### 5. MultipleMessagesReceived
-
-**Description:** Tests that multiple messages are published over time.
-
-- **Test Action:**
-  - Subscribe and count received messages
-  - Spin for a short duration
-- **Expected Result:** Message count is greater than 0
-
-## Test Infrastructure
-
-The test class `WheelSimulatorTest` provides:
-- Static `SetUpTestSuite()` and `TearDownTestSuite()` for ROS2 init/shutdown
-- Helper method `setupBasicWheelParams()` for setting up default test parameters
-
-## ROS2 Topics Used
-
-| Topic | Message Type | Direction |
-|-------|--------------|-----------|
-| `simulated_wheel_data` | std_msgs/msg/Float64MultiArray | Published by node under test |
-
-## Data Array Format
-
-The published Float64MultiArray contains wheel values in the following order:
-
-| Index | Wheel |
-|-------|-------|
-| 0 | Front Left (FL) |
-| 1 | Front Right (FR) |
-| 2 | Rear Left (RL) |
-| 3 | Rear Right (RR) |

docker-compose.yml

@@ -7,17 +7,6 @@ services:
         environment:
             - POSTGRES_PASSWORD=postgres
             - POSTGRES_USER=postgres
-            - POSTGRES_DB=imu_data
+            - POSTGRES_DB=grades
         ports:
             - "5432:5432"
-    mosquitto:
-        image: eclipse-mosquitto
-        container_name: mosquitto
-        restart: unless-stopped
-        ports:
-            - "1883:1883"
-            - "9001:9001"
-        volumes:
-            - ./mosquitto/config:/mosquitto/config
-            - ./mosquitto/data:/mosquitto/data
-            - ./mosquitto/log:/mosquitto/log

mosquitto/config/mosquitto.conf

@@ -1,15 +0,0 @@
-# Simple Mosquitto configuration allowing anonymous access (insecure for production)
-
-# pid_file /var/run/mosquitto.pid
-
-# Persistence
-#persistence true
-#persistence_location /var/lib/mosquitto/
-
-# Logging
-
-# Default MQTT listener
-listener 1883
-allow_anonymous true
-
-# Include additional config fragments

src/IMU/.clangd

@@ -1,2 +0,0 @@
-CompileFlags:
-    Remove: [-f*, -m*]

src/IMU/.devcontainer/Dockerfile

@@ -1,13 +0,0 @@
-ARG DOCKER_TAG=latest
-FROM espressif/idf:${DOCKER_TAG}
-
-ENV LC_ALL=C.UTF-8
-ENV LANG=C.UTF-8
-
-RUN apt-get update -y && apt-get install udev -y
-
-RUN echo "source /opt/esp/idf/export.sh > /dev/null 2>&1" >> ~/.bashrc
-
-ENTRYPOINT [ "/opt/esp/entrypoint.sh" ]
-
-CMD ["/bin/bash", "-c"]

src/IMU/.devcontainer/devcontainer.json

@@ -1,21 +0,0 @@
-{
-	"name": "ESP-IDF QEMU",
-	"build": {
-		"dockerfile": "Dockerfile"
-	},
-	"customizations": {
-		"vscode": {
-			"settings": {
-				"terminal.integrated.defaultProfile.linux": "bash",
-				"idf.espIdfPath": "/opt/esp/idf",
-				"idf.toolsPath": "/opt/esp",
-				"idf.gitPath": "/usr/bin/git"
-			},
-			"extensions": [
-				"espressif.esp-idf-extension",
-				"espressif.esp-idf-web"
-			]
-		}
-	},
-	"runArgs": ["--privileged"]
-}

src/IMU/CMakeLists.txt

@@ -1,6 +0,0 @@
-# The following lines of boilerplate have to be in your project's CMakeLists
-# in this exact order for cmake to work correctly
-cmake_minimum_required(VERSION 3.16)
-
-include($ENV{IDF_PATH}/tools/cmake/project.cmake)
-project(IMU)

src/IMU/main/CMakeLists.txt

@@ -1,2 +0,0 @@
-idf_component_register(SRCS "mpu6886.c"
-                       INCLUDE_DIRS ".")

src/IMU/main/Kconfig.projbuild

@@ -1,77 +0,0 @@
-menu "ESP32 IMU Project Configuration"
-
-    orsource "$IDF_PATH/examples/common_components/env_caps/$IDF_TARGET/Kconfig.env_caps"
-
-    menu "I2C Master Configuration"
-    config I2C_MASTER_SCL
-        int "SCL GPIO Num"
-        range ENV_GPIO_RANGE_MIN ENV_GPIO_OUT_RANGE_MAX
-        default 22
-        help
-            GPIO number for I2C Master clock line.
-
-    config I2C_MASTER_SDA
-        int "SDA GPIO Num"
-        range ENV_GPIO_RANGE_MIN ENV_GPIO_OUT_RANGE_MAX
-        default 21
-        help
-            GPIO number for I2C Master data line.
-
-    config I2C_MASTER_FREQUENCY
-        int "Master Frequency"
-        default 100000
-        help
-            I2C Speed of Master device.
-    endmenu
-
-    menu "MQTT Configuration"
-    config MQTT_BROKER_URI
-        string "MQTT Broker URI"
-        default "mqtt://192.168.4.2:1883"
-        help
-            URI of the MQTT broker to connect to.
-
-    config MQTT_TOPIC
-        string "MQTT Topic"
-        default "esp32/imu"
-        help
-            MQTT topic to publish IMU data to.
-    endmenu
-
-    menu "WiFi Access Point Configuration"
-    config WIFI_AP_MODE
-        bool "Enable WiFi AP Mode"
-        default y
-        help
-            Enable this option to start the device in Access Point mode.
-            If disabled, the device will start in Station mode.
-
-    config WIFI_SSID
-        string "WiFi SSID"
-        default "YourNetworkName"
-        depends on !WIFI_AP_MODE
-        help
-            SSID of WiFi network to connect to.
-
-    config WIFI_PASSWORD
-        string "WiFi Password"
-        default "YourPassword"
-        depends on !WIFI_AP_MODE
-        help
-            Password of WiFi network to connect to.
-
-    config WIFI_AP_SSID
-        string "WiFi AP SSID"
-        default "ESP32_IMU_AP"
-        depends on WIFI_AP_MODE
-        help
-            SSID of the WiFi Access Point when in AP mode.
-
-    config WIFI_AP_PASSWORD
-        string "WiFi AP Password"
-        default "esp32imuap"
-        depends on WIFI_AP_MODE
-        help
-            Password of the WiFi Access Point when in AP mode.
-    endmenu
-endmenu

src/IMU/main/mpu6886.c

@@ -1,351 +0,0 @@
-#include "mpu6886.h"
-
-
-static void IRAM_ATTR button_isr_handler(void* arg) {
-    uint32_t gpio_num = (uint32_t)arg;
-    // Keep it short — avoid delays, logging, malloc, etc.
-    mqtt_toggle = !mqtt_toggle;
-    toggle_completed = false;
-    esp_rom_printf("Button pressed! GPIO: %lu\n", gpio_num);
-}
-
-static void init_button(void) {
-    gpio_config_t io_conf = {
-        .intr_type = GPIO_INTR_NEGEDGE,   // Trigger on falling edge
-        .mode = GPIO_MODE_INPUT,
-        .pin_bit_mask = (1ULL << BOOT_BUTTON_GPIO),
-        .pull_up_en = GPIO_PULLUP_ENABLE, // Use pull-up since button pulls low
-        .pull_down_en = GPIO_PULLDOWN_DISABLE
-    };
-    gpio_config(&io_conf);
-
-    // Install GPIO ISR service
-    gpio_install_isr_service(0); // Pass 0 for default interrupt flags
-    // Attach the interrupt handler
-    gpio_isr_handler_add(BOOT_BUTTON_GPIO, button_isr_handler, (void*)BOOT_BUTTON_GPIO);
-}
-
-static void wifi_init()
-{
-    ESP_ERROR_CHECK(nvs_flash_init());
-    ESP_ERROR_CHECK(esp_netif_init());
-    ESP_ERROR_CHECK(esp_event_loop_create_default());
-
-    wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
-    ESP_ERROR_CHECK(esp_wifi_init(&cfg));
-
-#ifdef CONFIG_WIFI_AP_MODE
-    wifi_netif = esp_netif_create_default_wifi_ap();
-
-    wifi_config_t wifi_config = { 0 };
-    strncpy((char*)wifi_config.ap.ssid, CONFIG_WIFI_AP_SSID, sizeof(wifi_config.ap.ssid));
-    wifi_config.ap.ssid_len = strlen(CONFIG_WIFI_AP_SSID);
-    strncpy((char*)wifi_config.ap.password, CONFIG_WIFI_AP_PASSWORD, sizeof(wifi_config.ap.password));
-    wifi_config.ap.max_connection = 4;
-    if (strlen(CONFIG_WIFI_AP_PASSWORD) == 0) {
-        wifi_config.ap.authmode = WIFI_AUTH_OPEN;
-    } else {
-        wifi_config.ap.authmode = WIFI_AUTH_WPA_WPA2_PSK;
-    }
-
-    ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_AP));
-    ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_AP, &wifi_config));
-    ESP_ERROR_CHECK(esp_wifi_start());
-    ESP_LOGI("WIFI", "AP started SSID:%s", CONFIG_WIFI_AP_SSID);
-#else
-    wifi_netif = esp_netif_create_default_wifi_sta();
-
-    wifi_config_t wifi_config = {
-        .sta = {
-            .ssid = CONFIG_WIFI_SSID,
-            .password = CONFIG_WIFI_PASSWORD,
-        },
-    };
-
-    ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));
-    ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &wifi_config));
-    ESP_ERROR_CHECK(esp_wifi_start());
-    ESP_ERROR_CHECK(esp_wifi_connect());
-    ESP_LOGI("WIFI", "STA started, connecting to: %s", CONFIG_WIFI_SSID);
-#endif
-    wifi_initialized = true;
-}
-
-static void wifi_deinit(void)
-{
-    ESP_ERROR_CHECK(esp_wifi_stop());
-    ESP_ERROR_CHECK(esp_wifi_deinit());
-
-    if (wifi_netif != NULL) {
-    esp_netif_destroy_default_wifi(wifi_netif);
-    wifi_netif = NULL;
-    }
-
-    ESP_ERROR_CHECK(esp_event_loop_delete_default());
-    // ESP_ERROR_CHECK(esp_netif_deinit());
-    ESP_ERROR_CHECK(nvs_flash_deinit());
-    ESP_LOGI("WIFI", "Wi-Fi stopped and deinitialized");
-    wifi_initialized = false;
-}
-
-static void mqtt_app_start(void)
-{
-    esp_mqtt_client_config_t mqtt_cfg = { 0 };
-
-    mqtt_cfg.broker.address.uri = CONFIG_MQTT_BROKER_URI;
-
-    s_mqtt_client = esp_mqtt_client_init(&mqtt_cfg);
-    if (s_mqtt_client == NULL) {
-        ESP_LOGW("MQTT", "failed to init mqtt client");
-        return;
-    }
-    esp_mqtt_client_start(s_mqtt_client);
-}
-
-static void mqtt_app_stop(void)
-{
-    if (s_mqtt_client != NULL) {
-        esp_mqtt_client_stop(s_mqtt_client);
-        esp_mqtt_client_destroy(s_mqtt_client);
-        s_mqtt_client = NULL;
-    }
-}
-
-static esp_err_t mpu6886_write_byte(mpu6886_t* dev, uint8_t reg, uint8_t data) {
-    uint8_t tx[2] = { reg, data };
-    return i2c_master_write_to_device(dev->i2c_port, dev->address, tx, sizeof(tx), pdMS_TO_TICKS(100));
-}
-
-static esp_err_t mpu6886_read_bytes(mpu6886_t* dev, uint8_t reg, uint8_t* data, size_t len) {
-    return i2c_master_write_read_device(dev->i2c_port, dev->address, &reg, 1, data, len, pdMS_TO_TICKS(100));
-}
-
-static int16_t bytes_to_int16(uint8_t high, uint8_t low) {
-    return (int16_t)((high << 8) | low);
-}
-
-static esp_err_t mpu6886_update_sensitivity(mpu6886_t* dev)
-{
-    uint8_t aconf = 0, gconf = 0;
-    esp_err_t err;
-
-    err = mpu6886_read_bytes(dev, MPU6886_ACCEL_CONFIG, &aconf, 1);
-    if (err != ESP_OK) return err;
-    err = mpu6886_read_bytes(dev, MPU6886_GYRO_CONFIG, &gconf, 1);
-    if (err != ESP_OK) return err;
-
-    uint8_t a_fs = (aconf >> 3) & 0x03; // AFS_SEL bits [4:3]
-    switch (a_fs) {
-        case 0: dev->accel_div = ACCEL_SO_2G; break;   // ±2g
-        case 1: dev->accel_div = ACCEL_SO_4G; break;   // ±4g
-        case 2: dev->accel_div = ACCEL_SO_8G; break;   // ±8g
-        case 3: dev->accel_div = ACCEL_SO_16G; break;  // ±16g
-        default: dev->accel_div = ACCEL_SO_2G; break;
-    }
-
-    uint8_t g_fs = (gconf >> 3) & 0x03; // FS_SEL bits [4:3]
-    switch (g_fs) {
-        case 0: dev->gyro_div = GYRO_SO_250DPS; break;   // ±250 dps
-        case 1: dev->gyro_div = GYRO_SO_500DPS; break;   // ±500 dps
-        case 2: dev->gyro_div = GYRO_SO_1000DPS; break;  // ±1000 dps
-        case 3: dev->gyro_div = GYRO_SO_2000DPS; break;  // ±2000 dps
-        default: dev->gyro_div = GYRO_SO_250DPS; break;
-    }
-
-    return ESP_OK;
-}
-
-static esp_err_t i2c_master_init(i2c_port_t i2c_num, gpio_num_t sda_io, gpio_num_t scl_io, uint32_t clk_speed_hz)
-{
-    i2c_config_t conf = {
-        .mode = I2C_MODE_MASTER,
-        .sda_io_num = sda_io,
-        .sda_pullup_en = GPIO_PULLUP_ENABLE,
-        .scl_io_num = scl_io,
-        .scl_pullup_en = GPIO_PULLUP_ENABLE,
-        .master.clk_speed = clk_speed_hz,
-    };
-    esp_err_t err = i2c_param_config(i2c_num, &conf);
-    if (err != ESP_OK) return err;
-    return i2c_driver_install(i2c_num, I2C_MODE_MASTER, 0, 0, 0);
-}
-
-esp_err_t mpu6886_init(mpu6886_t* dev, i2c_port_t i2c_port) {
-    dev->i2c_port = i2c_port;
-    dev->address = MPU6886_ADDR;
-
-    uint8_t who_am_i = 0;
-    if (mpu6886_read_bytes(dev, MPU6886_WHO_AM_I, &who_am_i, 1) != ESP_OK) {
-        return ESP_FAIL;
-    }
-    if (who_am_i != 0x19) {
-        return ESP_FAIL;
-    }
-
-    // Reset
-    if (mpu6886_write_byte(dev, MPU6886_PWR_MGMT_1, 0x80) != ESP_OK) return ESP_FAIL;
-    vTaskDelay(pdMS_TO_TICKS(100));
-
-    // Auto select clock
-    if (mpu6886_write_byte(dev, MPU6886_PWR_MGMT_1, 0x01) != ESP_OK) return ESP_FAIL;
-
-    // Default config: set to ±2G accel, ±250DPS gyro
-    mpu6886_write_byte(dev, MPU6886_ACCEL_CONFIG, 0x00);
-    mpu6886_write_byte(dev, MPU6886_GYRO_CONFIG, 0x00);
-
-    dev->gyro_offset = (vec3_t) { 0, 0, 0 };
-    dev->accel_offset = (vec3_t) { 0, 0, 0 };
-
-    // detect actual sensitivities from device registers and set divisors
-    if (mpu6886_update_sensitivity(dev) != ESP_OK) {
-        // fallback to defaults if read fails
-        dev->accel_div = ACCEL_SO_2G;
-        dev->gyro_div = GYRO_SO_250DPS;
-    }
-
-    return ESP_OK;
-}
-
-esp_err_t mpu6886_read_accel(mpu6886_t* dev, vec3_t* accel) {
-    uint8_t buf[6];
-    esp_err_t ret = mpu6886_read_bytes(dev, MPU6886_ACCEL_XOUT_H, buf, 6);
-    if (ret != ESP_OK) return ret;
-
-    // convert raw -> m/s^2 and apply stored offsets
-    accel->x = (float)bytes_to_int16(buf[0], buf[1]) / dev->accel_div * SF_M_S2 - dev->accel_offset.x;
-    accel->y = (float)bytes_to_int16(buf[2], buf[3]) / dev->accel_div * SF_M_S2 - dev->accel_offset.y;
-    accel->z = (float)bytes_to_int16(buf[4], buf[5]) / dev->accel_div * SF_M_S2 - dev->accel_offset.z;
-    return ESP_OK;
-}
-
-esp_err_t mpu6886_read_gyro(mpu6886_t* dev, vec3_t* gyro) {
-    uint8_t buf[6];
-    esp_err_t ret = mpu6886_read_bytes(dev, MPU6886_GYRO_XOUT_H, buf, 6);
-    if (ret != ESP_OK) return ret;
-
-    gyro->x = (float)bytes_to_int16(buf[0], buf[1]) / dev->gyro_div * SF_RAD_S - dev->gyro_offset.x;
-    gyro->y = (float)bytes_to_int16(buf[2], buf[3]) / dev->gyro_div * SF_RAD_S - dev->gyro_offset.y;
-    gyro->z = (float)bytes_to_int16(buf[4], buf[5]) / dev->gyro_div * SF_RAD_S - dev->gyro_offset.z;
-    return ESP_OK;
-}
-
-esp_err_t mpu6886_read_temp(mpu6886_t* dev, float* temp) {
-    static uint8_t buf[2];
-    esp_err_t ret = mpu6886_read_bytes(dev, MPU6886_TEMP_OUT_H, buf, 2);
-    if (ret != ESP_OK) return ret;
-
-    int16_t raw = bytes_to_int16(buf[0], buf[1]);
-    *temp = ((float)raw / TEMP_SO) + TEMP_OFFSET;
-    return ESP_OK;
-}
-
-esp_err_t mpu6886_calibrate_gyro(mpu6886_t* dev, int samples, int delay_ms) {
-    vec3_t sum = { 0, 0, 0 }, g;
-    for (int i = 0; i < samples; i++) {
-        if (mpu6886_read_gyro(dev, &g) != ESP_OK) return ESP_FAIL;
-        sum.x += g.x;
-        sum.y += g.y;
-        sum.z += g.z;
-        vTaskDelay(pdMS_TO_TICKS(delay_ms));
-    }
-    dev->gyro_offset.x = sum.x / samples;
-    dev->gyro_offset.y = sum.y / samples;
-    dev->gyro_offset.z = sum.z / samples;
-    return ESP_OK;
-}
-
-esp_err_t mpu6886_calibrate_accel(mpu6886_t* dev, int samples, int delay_ms)
-{
-    // Calibrate accelerometer offsets while the device is stationary.
-    // The function will detect the device full-scale and compute offsets in m/s^2.
-    vec3_t sum = { 0, 0, 0 }, a;
-    for (int i = 0; i < samples; i++) {
-        if (mpu6886_read_accel(dev, &a) != ESP_OK) {
-            return ESP_FAIL;
-        }
-        sum.x += a.x;
-        sum.y += a.y;
-        sum.z += a.z;
-        vTaskDelay(pdMS_TO_TICKS(delay_ms));
-    }
-    vec3_t avg = { sum.x / samples, sum.y / samples, sum.z / samples };
-
-    // For X/Y expect ~0 m/s^2 when stationary; offset = measured average
-    dev->accel_offset.x = avg.x;
-    dev->accel_offset.y = avg.y;
-
-    // For Z expect ~+1g (SF_M_S2) if +Z points up. If device is flipped you'll get -1g.
-    // Compute expected gravity sign from measured avg.z magnitude and sign.
-    float expected_g = (avg.z < 0) ? -SF_M_S2 : SF_M_S2;
-    dev->accel_offset.z = avg.z - expected_g;
-
-    return ESP_OK;
-}
-
-void app_main(void)
-{
-    esp_err_t err = i2c_master_init(I2C_NUM_0, CONFIG_I2C_MASTER_SDA, CONFIG_I2C_MASTER_SCL, CONFIG_I2C_MASTER_FREQUENCY); // adjust pins if needed
-    if (err != ESP_OK) {
-        ESP_LOGE("MPU6886", "I2C init failed: %d", err);
-        return;
-    }
-
-    init_button();
-    gpio_reset_pin(LED_GPIO);
-    gpio_set_direction(LED_GPIO, GPIO_MODE_OUTPUT);
-
-    mpu6886_t mpu;
-    mpu.i2c_port = I2C_NUM_0;
-    mpu.address = MPU6886_ADDR;
-
-    esp_err_t ret = mpu6886_init(&mpu, I2C_NUM_0);
-    if (ret != ESP_OK) {
-        ESP_LOGE("MPU6886", "init failed");
-        return;
-    }
-
-    mpu6886_calibrate_gyro(&mpu, 100, 10);
-    mpu6886_calibrate_accel(&mpu, 100, 10);
-    vec3_t accel, gyro;
-    float temp;
-
-    while (1) {
-        if (mqtt_toggle && !toggle_completed && !wifi_initialized) {
-            wifi_init();
-            mqtt_app_start();
-            ESP_LOGI("BOOT", "Boot button pressed: starting MQTT mode");
-            gpio_set_level(LED_GPIO, 1);
-            toggle_completed = true;
-        } else if (!mqtt_toggle && !toggle_completed && wifi_initialized) {
-            mqtt_app_stop();
-            wifi_deinit();
-            ESP_LOGI("BOOT", "Boot button not pressed: starting serial-only mode");
-            gpio_set_level(LED_GPIO, 0);
-            toggle_completed = true;
-        }
-        mpu6886_read_accel(&mpu, &accel);
-        mpu6886_read_gyro(&mpu, &gyro);
-        mpu6886_read_temp(&mpu, &temp);
-
-        if (mqtt_toggle && s_mqtt_client != NULL) {
-            char payload[256];
-            int n = snprintf(payload, sizeof(payload),
-                "{\"accel\":{\"x\":%8.3f,\"y\":%8.3f,\"z\":%8.3f},\"gyro\":{\"x\":%8.3f,\"y\":%8.3f,\"z\":%8.3f},\"Temp\":%8.2f}",
-                accel.x, accel.y, accel.z,
-                gyro.x, gyro.y, gyro.z,
-                temp);
-            if (n > 0 && n < (int)sizeof(payload)) {
-                int msg_id = esp_mqtt_client_publish(s_mqtt_client, CONFIG_MQTT_TOPIC, payload, 0, 1, 0);
-                ESP_LOGD("MQTT", "published msg_id=%d payload_len=%d", msg_id, n);
-            } else {
-                ESP_LOGW("MQTT", "payload truncated or encoding error");
-            }
-        } else {
-            printf("{\"accel\":{\"x\":%8.3f,\"y\":%8.3f,\"z\":%8.3f},\"gyro\":{\"x\":%8.3f,\"y\":%8.3f,\"z\":%8.3f},\"Temp\":%8.2f}\n",
-               accel.x, accel.y, accel.z,
-               gyro.x, gyro.y, gyro.z,
-               temp);
-        }
-        vTaskDelay(pdMS_TO_TICKS(500));
-    }
-}

src/IMU/main/mpu6886.h

@@ -1,91 +0,0 @@
-#ifndef MPU6886_H
-#define MPU6886_H
-
-#include "driver/i2c.h"
-#include "esp_err.h"
-#include "esp_wifi.h"
-#include "esp_event.h"
-#include "esp_log.h"
-#include "nvs_flash.h"
-#include "freertos/FreeRTOS.h"
-#include "freertos/task.h"
-#include <math.h>
-#include "mqtt_client.h"
-#include <string.h>
-#include <stdio.h>
-#include "driver/gpio.h"
-#include "esp_rom_sys.h"
-
-
-#define I2C_MASTER_SCL_IO           CONFIG_I2C_MASTER_SCL       /*!< GPIO number used for I2C master clock */
-#define I2C_MASTER_SDA_IO           CONFIG_I2C_MASTER_SDA       /*!< GPIO number used for I2C master data  */
-#define I2C_MASTER_NUM              I2C_NUM_0                   /*!< I2C port number for master dev */
-#define I2C_MASTER_FREQ_HZ          CONFIG_I2C_MASTER_FREQUENCY /*!< I2C master clock frequency */
-#define I2C_MASTER_TX_BUF_DISABLE   0                           /*!< I2C master doesn't need buffer */
-#define I2C_MASTER_RX_BUF_DISABLE   0                           /*!< I2C master doesn't need buffer */
-#define I2C_MASTER_TIMEOUT_MS       1000
-
-#define BOOT_BUTTON_GPIO 0 // GPIO number for boot mode selection button
-#define LED_GPIO 33         // GPIO number for onboard LED
-
-#define MPU6886_ADDR 0x68
-
-// MPU6886 Registers
-#define MPU6886_PWR_MGMT_1     0x6B
-#define MPU6886_WHO_AM_I       0x75
-#define MPU6886_ACCEL_XOUT_H   0x3B
-#define MPU6886_GYRO_XOUT_H    0x43
-#define MPU6886_TEMP_OUT_H     0x41
-#define MPU6886_ACCEL_CONFIG   0x1C
-#define MPU6886_GYRO_CONFIG    0x1B
-
-// Sensitivity scales
-#define ACCEL_SO_2G  16384.0f
-#define ACCEL_SO_4G   8192.0f
-#define ACCEL_SO_8G   4096.0f
-#define ACCEL_SO_16G  2048.0f
-
-#define GYRO_SO_250DPS  131.0f
-#define GYRO_SO_500DPS   65.5f
-#define GYRO_SO_1000DPS  32.8f
-#define GYRO_SO_2000DPS  16.4f
-
-#define TEMP_SO 326.8f
-#define TEMP_OFFSET 25.0f
-
-// Scale factors
-#define SF_M_S2 9.80665f
-#define SF_RAD_S 0.017453292519943f // pi/180
-
-typedef struct {
-    float x;
-    float y;
-    float z;
-} vec3_t;
-
-typedef struct {
-    i2c_port_t i2c_port;
-    uint8_t address;
-    float accel_div;
-    float gyro_div;
-    vec3_t gyro_offset;
-    vec3_t accel_offset;
-} mpu6886_t;
-
-bool mqtt_toggle = true;
-bool toggle_completed = false;
-bool wifi_initialized = false;
-
-esp_netif_t* wifi_netif = NULL;
-
-static esp_mqtt_client_handle_t s_mqtt_client = NULL;
-
-// Function declarations
-esp_err_t mpu6886_init(mpu6886_t *dev, i2c_port_t i2c_port);
-esp_err_t mpu6886_read_accel(mpu6886_t *dev, vec3_t *accel);
-esp_err_t mpu6886_read_gyro(mpu6886_t *dev, vec3_t *gyro);
-esp_err_t mpu6886_read_temp(mpu6886_t *dev, float *temp);
-esp_err_t mpu6886_calibrate_gyro(mpu6886_t *dev, int samples, int delay_ms);
-esp_err_t mpu6886_calibrate_accel(mpu6886_t *dev, int samples, int delay_ms);
-
-#endif

src/config.toml

@@ -1,7 +1,7 @@
 [database]
 host = "localhost"
 port = 5432
-dbname = "imu_data"
+dbname = "grades"
 user = "postgres"
 password = "postgres"
 timeout = 30

src/g2_2025_assign1_interfaces_pkg/CMakeLists.txt

@@ -0,0 +1,23 @@
+cmake_minimum_required(VERSION 3.8)
+project(g2_2025_assign1_interfaces_pkg)
+
+if(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+  add_compile_options(-Wall -Wextra -Wpedantic)
+endif()
+
+# find dependencies
+find_package(ament_cmake REQUIRED)
+find_package(rosidl_default_generators REQUIRED)
+find_package(builtin_interfaces REQUIRED)
+
+rosidl_generate_interfaces(${PROJECT_NAME}
+    "msg/Student.msg"
+    "msg/Exam.msg"
+    "srv/Exams.srv"
+    "action/Retake.action"
+    DEPENDENCIES builtin_interfaces
+)
+
+ament_export_dependencies(rosidl_default_runtime)
+
+ament_package()

src/g2_2025_assign1_interfaces_pkg/action/Retake.action

@@ -0,0 +1,6 @@
+string student_name
+string course_name
+---
+float32 result
+---
+string status

src/g2_2025_assign1_interfaces_pkg/msg/Exam.msg

@@ -0,0 +1,4 @@
+string student_name
+string course_name
+int32 result
+builtin_interfaces/Time timestamp

src/g2_2025_assign1_interfaces_pkg/msg/Student.msg

@@ -0,0 +1,3 @@
+string student_name
+string course_name
+builtin_interfaces/Time timestamp

src/g2_2025_assign1_interfaces_pkg/package.xml

@@ -1,21 +1,22 @@
 <?xml version="1.0"?>
 <?xml-model href="http://download.ros.org/schema/package_format3.xsd" schematypens="http://www.w3.org/2001/XMLSchema"?>
 <package format="3">
-  <name>g2_2025_odometry_pkg</name>
+  <name>g2_2025_assign1_interfaces_pkg</name>
   <version>0.0.0</version>
   <description>TODO: Package description</description>
-  <maintainer email="contact@wessel.gg">wessel</maintainer>
+  <maintainer email="wessel@todo.todo">wessel</maintainer>
   <license>TODO: License declaration</license>
 
   <buildtool_depend>ament_cmake</buildtool_depend>
 
-  <depend>rclcpp</depend>
-  <depend>sensor_msgs</depend>
-  <depend>geometry_msgs</depend>
+  <build_depend>rosidl_default_generators</build_depend>
+  <build_depend>builtin_interfaces</build_depend>
+  <exec_depend>rosidl_default_runtime</exec_depend>
+  <exec_depend>builtin_interfaces</exec_depend>
+  <member_of_group>rosidl_interface_packages</member_of_group>
 
   <test_depend>ament_lint_auto</test_depend>
   <test_depend>ament_lint_common</test_depend>
-  <test_depend>ament_cmake_gtest</test_depend>
 
   <export>
     <build_type>ament_cmake</build_type>

src/g2_2025_assign1_interfaces_pkg/srv/Exams.srv

@@ -0,0 +1,7 @@
+# Request
+string student_name
+string course_name
+int32[] exam_grades
+---
+# Response
+int32 result  # Final result

src/g2_2025_assign1_pkg/CMakeLists.txt

@@ -0,0 +1,239 @@
+cmake_minimum_required(VERSION 3.8)
+project(g2_2025_assign1_pkg)
+
+if(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+  add_compile_options(-Wall -Wextra -Wpedantic)
+endif()
+
+# external packages
+include(FetchContent)
+
+fetchcontent_declare(
+    tomlplusplus
+    GIT_REPOSITORY https://github.com/marzer/tomlplusplus.git
+    GIT_TAG v3.4.0
+)
+
+fetchcontent_makeavailable(tomlplusplus)
+
+# find dependencies
+find_package(ament_cmake REQUIRED)
+find_package(rclcpp REQUIRED)
+find_package(rclcpp_action REQUIRED)
+find_package(std_msgs REQUIRED)
+find_package(g2_2025_assign1_interfaces_pkg REQUIRED)
+
+add_executable(g2_2025_exam_result_generator_node
+    src/g2_2025_exam_result_generator_node/Main.cpp
+    src/database/DatabaseManager.cpp
+    src/config/ConfigManager.cpp
+    src/g2_2025_exam_result_generator_node/nodes/ExamResultGenerator.cpp
+)
+target_include_directories(g2_2025_exam_result_generator_node PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}/src
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/g2_2025_exam_result_generator_node
+)
+ament_target_dependencies(g2_2025_exam_result_generator_node rclcpp g2_2025_assign1_interfaces_pkg)
+target_link_libraries(g2_2025_exam_result_generator_node pqxx pq tomlplusplus::tomlplusplus)
+
+add_executable(g2_2025_final_grade_determinator_node
+    src/g2_2025_final_grade_determinator_node/main.cpp
+    src/database/DatabaseManager.cpp
+    src/config/ConfigManager.cpp
+    src/g2_2025_final_grade_determinator_node/nodes/FinalGradeDeterminator.cpp
+)
+target_include_directories(g2_2025_final_grade_determinator_node PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}/src
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/g2_2025_final_grade_determinator_node
+)
+ament_target_dependencies(g2_2025_final_grade_determinator_node rclcpp g2_2025_assign1_interfaces_pkg)
+target_link_libraries(g2_2025_final_grade_determinator_node pqxx pq tomlplusplus::tomlplusplus)
+
+
+add_executable(g2_2025_grade_calculator_node
+    src/g2_2025_grade_calculator_node/main.cpp
+    src/g2_2025_grade_calculator_node/nodes/GradeCalculator.cpp
+)
+ament_target_dependencies(g2_2025_grade_calculator_node rclcpp g2_2025_assign1_interfaces_pkg)
+
+add_executable(g2_2025_retake_grade_determinator_node
+    src/g2_2025_retake_grade_determinator_node/main.cpp
+    src/database/DatabaseManager.cpp
+    src/config/ConfigManager.cpp
+    src/g2_2025_retake_grade_determinator_node/nodes/RetakeGradeDeterminator.cpp
+)
+ament_target_dependencies(g2_2025_retake_grade_determinator_node rclcpp_action rclcpp g2_2025_assign1_interfaces_pkg)
+target_link_libraries(g2_2025_retake_grade_determinator_node pqxx pq tomlplusplus::tomlplusplus)
+
+add_executable(g2_2025_retake_scheduler_node
+    src/g2_2025_retake_scheduler_node/main.cpp
+    src/database/DatabaseManager.cpp
+    src/config/ConfigManager.cpp
+    src/g2_2025_retake_scheduler_node/nodes/RetakeScheduler.cpp
+)
+ament_target_dependencies(g2_2025_retake_scheduler_node rclcpp_action rclcpp g2_2025_assign1_interfaces_pkg)
+target_link_libraries(g2_2025_retake_scheduler_node pqxx pq tomlplusplus::tomlplusplus)
+
+
+target_include_directories(g2_2025_retake_scheduler_node PRIVATE
+  ${CMAKE_CURRENT_SOURCE_DIR}/src
+  ${CMAKE_CURRENT_SOURCE_DIR}/src/g2_2025_retake_scheduler_node
+#   ${CMAKE_CURRENT_SOURCE_DIR}/src/g2_2025_grade_calculator_pkg/database
+)
+
+target_include_directories(g2_2025_retake_grade_determinator_node PRIVATE
+  ${CMAKE_CURRENT_SOURCE_DIR}/src
+  ${CMAKE_CURRENT_SOURCE_DIR}/src/g2_2025_retake_grade_determinator_node
+#   ${CMAKE_CURRENT_SOURCE_DIR}/src/g2_2025_grade_calculator_pkg/database
+)
+
+install(
+    TARGETS
+        g2_2025_exam_result_generator_node
+        g2_2025_final_grade_determinator_node
+        g2_2025_grade_calculator_node
+        g2_2025_retake_grade_determinator_node
+        g2_2025_retake_scheduler_node
+    DESTINATION lib/${PROJECT_NAME}
+)
+
+install(
+    DIRECTORY launch
+    DESTINATION share/${PROJECT_NAME}/
+)
+
+if(BUILD_TESTING)
+  find_package(ament_cmake_gtest REQUIRED)
+
+  # Add gtest for ConfigManager
+  ament_add_gtest(${PROJECT_NAME}_test_config_manager
+    test/ConfigManager.test.cpp
+    src/config/ConfigManager.cpp
+  )
+  target_include_directories(${PROJECT_NAME}_test_config_manager PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}/src
+  )
+  ament_target_dependencies(${PROJECT_NAME}_test_config_manager
+    rclcpp
+  )
+  target_link_libraries(${PROJECT_NAME}_test_config_manager
+    tomlplusplus::tomlplusplus
+  )
+
+  # Add gtest for DatabaseManager
+  ament_add_gtest(${PROJECT_NAME}_test_database_manager
+    test/DatabaseManager.test.cpp
+    src/database/DatabaseManager.cpp
+    src/config/ConfigManager.cpp
+  )
+  target_include_directories(${PROJECT_NAME}_test_database_manager PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}/src
+  )
+  ament_target_dependencies(${PROJECT_NAME}_test_database_manager
+    rclcpp
+    g2_2025_assign1_interfaces_pkg
+  )
+  target_link_libraries(${PROJECT_NAME}_test_database_manager
+    pqxx pq tomlplusplus::tomlplusplus
+  )
+
+  # Add gtest for ExamResultGenerator
+  ament_add_gtest(${PROJECT_NAME}_test_exam_result_generator
+    test/ExamResultGenerator.test.cpp
+    src/g2_2025_exam_result_generator_node/nodes/ExamResultGenerator.cpp
+    src/database/DatabaseManager.cpp
+    src/config/ConfigManager.cpp
+  )
+  target_include_directories(${PROJECT_NAME}_test_exam_result_generator PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}/src
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/g2_2025_exam_result_generator_node
+  )
+  ament_target_dependencies(${PROJECT_NAME}_test_exam_result_generator
+    rclcpp
+    g2_2025_assign1_interfaces_pkg
+  )
+  target_link_libraries(${PROJECT_NAME}_test_exam_result_generator
+    pqxx pq tomlplusplus::tomlplusplus
+  )
+
+  # Add gtest for GradeCalculator
+  ament_add_gtest(${PROJECT_NAME}_test_grade_calculator
+    test/GradeCalculator.test.cpp
+    src/g2_2025_grade_calculator_node/nodes/GradeCalculator.cpp
+  )
+  target_include_directories(${PROJECT_NAME}_test_grade_calculator PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}/src
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/g2_2025_grade_calculator_node
+  )
+  ament_target_dependencies(${PROJECT_NAME}_test_grade_calculator
+    rclcpp
+    g2_2025_assign1_interfaces_pkg
+  )
+
+  # Add gtest for FinalGradeDeterminator
+  ament_add_gtest(${PROJECT_NAME}_test_final_grade_determinator
+    test/FinalGradeDeterminator.test.cpp
+    src/g2_2025_final_grade_determinator_node/nodes/FinalGradeDeterminator.cpp
+    src/database/DatabaseManager.cpp
+    src/config/ConfigManager.cpp
+  )
+  target_include_directories(${PROJECT_NAME}_test_final_grade_determinator PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}/src
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/g2_2025_final_grade_determinator_node
+  )
+  ament_target_dependencies(${PROJECT_NAME}_test_final_grade_determinator
+    rclcpp
+    g2_2025_assign1_interfaces_pkg
+  )
+  target_link_libraries(${PROJECT_NAME}_test_final_grade_determinator
+    pqxx pq tomlplusplus::tomlplusplus
+  )
+
+  # Add gtest for RetakeGradeDeterminator
+  ament_add_gtest(${PROJECT_NAME}_test_retake_grade_determinator
+    test/RetakeGradeDeterminator.test.cpp
+    src/g2_2025_retake_grade_determinator_node/nodes/RetakeGradeDeterminator.cpp
+    src/database/DatabaseManager.cpp
+    src/config/ConfigManager.cpp
+  )
+  target_include_directories(${PROJECT_NAME}_test_retake_grade_determinator PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}/src
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/g2_2025_retake_grade_determinator_node
+  )
+  ament_target_dependencies(${PROJECT_NAME}_test_retake_grade_determinator
+    rclcpp
+    rclcpp_action
+    g2_2025_assign1_interfaces_pkg
+  )
+  target_link_libraries(${PROJECT_NAME}_test_retake_grade_determinator
+    pqxx pq tomlplusplus::tomlplusplus
+  )
+
+  # Add gtest for RetakeScheduler
+  ament_add_gtest(${PROJECT_NAME}_test_retake_scheduler
+    test/RetakeScheduler.test.cpp
+    src/g2_2025_retake_scheduler_node/nodes/RetakeScheduler.cpp
+    src/database/DatabaseManager.cpp
+    src/config/ConfigManager.cpp
+  )
+  target_include_directories(${PROJECT_NAME}_test_retake_scheduler PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}/src
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/g2_2025_retake_scheduler_node
+  )
+  ament_target_dependencies(${PROJECT_NAME}_test_retake_scheduler
+    rclcpp
+    rclcpp_action
+    g2_2025_assign1_interfaces_pkg
+  )
+  target_link_libraries(${PROJECT_NAME}_test_retake_scheduler
+    pqxx pq tomlplusplus::tomlplusplus
+  )
+
+  # Add Python integration tests
+#   find_package(ament_cmake_pytest REQUIRED)
+#   ament_add_pytest_test(${PROJECT_NAME}_integration_test test/test_integration_system.py
+#     TIMEOUT 60
+#   )
+endif()
+
+ament_package()

src/g2_2025_assign1_pkg/launch/grade_calculator.launch.xml

@@ -0,0 +1,14 @@
+<launch>
+    <node pkg="g2_2025_assign1_pkg" exec="g2_2025_exam_result_generator_node">
+        <param name="delay_between_grades_ms" value="2000"/>
+    </node>
+    <node pkg="g2_2025_assign1_pkg" exec="g2_2025_final_grade_determinator_node">
+        <param name="grade_collection_amount" value="5"/>
+    </node>
+    <node pkg="g2_2025_assign1_pkg" exec="g2_2025_grade_calculator_node"/>
+    <node pkg="g2_2025_assign1_pkg" exec="g2_2025_retake_grade_determinator_node"/>
+    <node pkg="g2_2025_assign1_pkg" exec="g2_2025_retake_scheduler_node">
+        <param name="retake_check_interval_sec" value="120"/>
+    </node>
+
+</launch>

src/g2_2025_assign1_pkg/package.xml

@@ -1,15 +1,16 @@
 <?xml version="1.0"?>
 <?xml-model href="http://download.ros.org/schema/package_format3.xsd" schematypens="http://www.w3.org/2001/XMLSchema"?>
 <package format="3">
-  <name>g2_2025_imu_reader_pkg</name>
+  <name>g2_2025_assign1_pkg</name>
   <version>0.0.0</version>
   <description>TODO: Package description</description>
   <maintainer email="wessel@go2it.eu">wessel</maintainer>
   <license>TODO: License declaration</license>
 
   <buildtool_depend>ament_cmake</buildtool_depend>
+
   <depend>rclcpp</depend>
-  <depend>sensor_msgs</depend>
+  <depend>g2_2025_interfaces</depend>
 
   <export>
     <build_type>ament_cmake</build_type>

src/g2_2025_assign1_pkg/src/config/ConfigManager.cpp

@@ -3,7 +3,7 @@
 #include <iostream>
 #include <fstream>
 
-namespace assignments::two {
+namespace assignments::one {
 
 ConfigManager::ConfigManager(rclcpp::Logger logger)
     : logger_(logger), loaded_(false)
@@ -83,7 +83,7 @@ DatabaseConfig ConfigManager::parse_database_config(const toml::table& config) c
 
     db_config.host = database_section["host"].value_or<std::string>("localhost");
     db_config.port = database_section["port"].value_or<int>(5432);
-    db_config.dbname = database_section["dbname"].value_or<std::string>("imu_data");
+    db_config.dbname = database_section["dbname"].value_or<std::string>("grades");
     db_config.user = database_section["user"].value_or<std::string>("postgres");
     db_config.password = database_section["password"].value_or<std::string>("postgres");
     db_config.timeout = database_section["timeout"].value_or<int>(30);
@@ -109,4 +109,4 @@ DatabaseConfig ConfigManager::parse_database_config(const toml::table& config) c
     return db_config;
 }
 
-} // namespace assignments::two
+} // namespace assignments::one

src/g2_2025_assign1_pkg/src/config/ConfigManager.hpp

@@ -16,7 +16,7 @@
 
 #include "DatabaseConfig.hpp"
 
-namespace assignments::two {
+namespace assignments::one {
 
 class ConfigManager {
 public:
@@ -49,4 +49,4 @@ private:
     DatabaseConfig parse_database_config(const toml::table& config) const;
 };
 
-} // namespace assignments::two
+} // namespace assignments::one

src/g2_2025_assign1_pkg/src/config/DatabaseConfig.hpp

@@ -1,5 +1,5 @@
 /* DatabaseConfig.hpp
- * Database configuration structure
+ * Database configuration structure for the exam result generator
  *
  * Reviewed by: <x>
  * Changelog:
@@ -9,7 +9,7 @@
 
 #include <string>
 
-namespace assignments::three {
+namespace assignments::one {
 
 struct DatabaseConfig {
     std::string host;
@@ -43,4 +43,4 @@ struct DatabaseConfig {
     }
 };
 
-} // namespace assignments::three
+} // namespace assignments::one

src/g2_2025_assign1_pkg/src/database/DatabaseManager.cpp

@@ -0,0 +1,317 @@
+#include "DatabaseManager.hpp"
+
+#include <pqxx/pqxx>
+#include "rclcpp/rclcpp.hpp"
+
+#include "SQLQueries.hpp"
+#include "config/ConfigManager.hpp"
+
+namespace assignments::one {
+
+DatabaseManager::DatabaseManager(rclcpp::Logger logger) : logger_(logger) {
+    config_manager_ = std::make_unique<ConfigManager>(logger_);
+    init_database();
+}
+
+bool DatabaseManager::is_connected() const {
+    return conn_ && conn_->is_open();
+}
+
+bool DatabaseManager::connect(const std::string& connection_string) {
+    try {
+        RCLCPP_INFO(logger_, "[DBS] connecting to PostgreSQL database...");
+
+        conn_ = std::make_unique<pqxx::connection>(connection_string);
+
+        if (conn_->is_open()) {
+            RCLCPP_INFO(logger_, "[DBS] successfully connected to database (%s)", conn_->dbname());
+            return true;
+        } else {
+            RCLCPP_ERROR(logger_, "[DBS] failed to open database connection");
+            return false;
+        }
+
+    } catch (const pqxx::sql_error &e) {
+        RCLCPP_ERROR(logger_, "[DBS] sql error: %s", e.what());
+        return false;
+    } catch (const std::exception &e) {
+        RCLCPP_ERROR(logger_, "[DBS] connection error: %s", e.what());
+        return false;
+    }
+}
+
+void DatabaseManager::init_database() {
+    if (!config_manager_ || !config_manager_->is_loaded()) {
+        RCLCPP_ERROR(logger_, "[DBS] configuration not loaded, cannot initialize database");
+        return;
+    }
+
+    auto db_config = config_manager_->get_database_config();
+    if (!db_config.has_value()) {
+        RCLCPP_ERROR(logger_, "[DBS] failed to get database configuration");
+        return;
+    }
+
+    std::string connection_string = db_config->to_connection_string();
+
+    if (connect(connection_string)) {
+        create_tables();
+        insert_sample_data();
+    }
+}
+
+std::vector<StudentCourse> DatabaseManager::queue_pending_combinations() {
+    std::vector<StudentCourse> combinations;
+
+    if (!is_connected()) {
+        return combinations;
+    }
+
+    try {
+        pqxx::work txn(*conn_);
+
+        auto result = txn.exec(SQL_SELECT_MISSING_RESULTS);
+
+        for (const auto& row : result) {
+            StudentCourse sc;
+            sc.student_name = row[0].as<std::string>();
+            sc.course_name = row[1].as<std::string>();
+            combinations.push_back(sc);
+        }
+
+        RCLCPP_INFO(logger_, "[DBS] queued %zu pending combinations", combinations.size());
+
+    } catch (const pqxx::sql_error &e) {
+        RCLCPP_ERROR(logger_, "[DBS] queueing combinations failed: %s", e.what());
+    } catch (const std::exception &e) {
+        RCLCPP_ERROR(logger_, "[DBS] database error: %s", e.what());
+    }
+
+    return combinations;
+}
+
+bool DatabaseManager::enroll_student_into_course(const StudentCourse& sc) {
+    if (!is_connected()) {
+        return false;
+    }
+
+    try {
+        pqxx::work txn(*conn_);
+
+        txn.exec_params(SQL_INSERT_STUDENT_ENROLLMENT, sc.student_name, sc.course_name);
+
+        txn.commit();
+        return true;
+
+    } catch (const pqxx::sql_error &e) {
+        RCLCPP_ERROR(logger_, "[DBS] enroll student into course failed: %s", e.what());
+        return false;
+    } catch (const std::exception &e) {
+        RCLCPP_ERROR(logger_, "[DBS] database error: %s", e.what());
+        return false;
+    }
+}
+
+bool DatabaseManager::remove_student_from_course(const StudentCourse& sc) {
+    if (!is_connected()) {
+        return false;
+    }
+
+    try {
+        pqxx::work txn(*conn_);
+
+        txn.exec_params(SQL_DELETE_STUDENT_ENROLLMENT, sc.student_name, sc.course_name);
+
+        txn.commit();
+        return true;
+
+    } catch (const pqxx::sql_error &e) {
+        RCLCPP_ERROR(logger_, "[DBS] unenroll student from course failed: %s", e.what());
+        return false;
+    } catch (const std::exception &e) {
+        RCLCPP_ERROR(logger_, "[DBS] database error: %s", e.what());
+        return false;
+    }
+}
+
+bool DatabaseManager::store_exam_result(const std::string& student_name, const std::string& course_name, int grade) {
+    if (!is_connected()) return false;
+
+    try {
+        pqxx::work txn(*conn_);
+
+        txn.exec_params(
+            SQL_INSERT_EXAM_RESULT,
+            student_name, course_name, grade
+        );
+
+        txn.commit();
+        return true;
+
+    } catch (const pqxx::sql_error &e) {
+        RCLCPP_ERROR(logger_, "[DBS] store result failed: %s", e.what());
+        return false;
+    } catch (const std::exception &e) {
+        RCLCPP_ERROR(logger_, "[DBS] database error: %s", e.what());
+        return false;
+    }
+}
+
+bool DatabaseManager::store_final_course_result(
+    const StudentCourse& sc,
+    int exam_count,
+    int final_grade,
+    bool is_retake
+) {
+    if (!is_connected()) return false;
+
+    try {
+        pqxx::work txn(*conn_);
+
+        txn.exec_params(
+            SQL_INSERT_FINAL_COURSE_RESULT,
+            sc.student_name, sc.course_name, exam_count, final_grade, is_retake
+        );
+
+        txn.commit();
+        return true;
+
+    } catch (const pqxx::sql_error &e) {
+        RCLCPP_ERROR(logger_, "[DBS] store final course result failed: %s", e.what());
+        return false;
+    } catch (const std::exception &e) {
+        RCLCPP_ERROR(logger_, "[DBS] database error: %s", e.what());
+        return false;
+    }
+}
+
+void DatabaseManager::create_tables() {
+    if (!conn_ || !conn_->is_open()) return;
+
+    try {
+        pqxx::work txn(*conn_);
+
+        txn.exec(SQL_CREATE_ENROLLMENTS_TABLE);
+        txn.exec(SQL_CREATE_EXAM_RESULTS);
+        txn.exec(SQL_CREATE_COURSE_RESULTS);
+
+        txn.commit();
+
+        RCLCPP_INFO(logger_, "[DBS] database tables ready");
+
+    } catch (const pqxx::sql_error &e) {
+        RCLCPP_ERROR(logger_, "[DBS] CREATE TABLE failed: %s", e.what());
+    } catch (const std::exception &e) {
+        RCLCPP_ERROR(logger_, "[DBS] database error: %s", e.what());
+    }
+}
+
+void DatabaseManager::insert_sample_data() {
+    if (!is_connected()) {
+        return;
+    }
+
+    try {
+        pqxx::work txn(*conn_);
+
+        auto student_result = txn.exec(SQL_SELECT_STUDENT_LIST);
+        int student_count = student_result[0][0].as<int>();
+
+        auto grades_result = txn.exec(SQL_SELECT_EXAM_RESULTS_COUNT);
+        int grades_count = grades_result[0][0].as<int>();
+
+        if (student_count == 0 && grades_count == 0) {
+            for (const auto& [student, course] : sample_students_data_) {
+                txn.exec_params(SQL_INSERT_STUDENT_ENROLLMENT, student, course);
+            }
+
+            txn.commit();
+            RCLCPP_INFO(logger_, "[DBS] inserted sample student enrollment data");
+        }
+
+    } catch (const pqxx::sql_error &e) {
+        RCLCPP_ERROR(logger_, "[DBS] insert sample data failed: %s", e.what());
+    } catch (const std::exception &e) {
+        RCLCPP_ERROR(logger_, "[DBS] database error: %s", e.what());
+    }
+}
+
+int DatabaseManager::get_final_course_grade(const StudentCourse& sc) {
+    if (!is_connected()) return -1;
+
+    try {
+        pqxx::work txn(*conn_);
+
+        auto result = txn.exec_params(SQL_SELECT_STUDENT_EXAM_RESULTS, sc.student_name, sc.course_name);
+
+        if (result.size() == 1) {
+            int exam_count = result[0][0].as<int>();
+            if (exam_count == 0) {
+                return -1; // No exams taken
+            }
+            int avg_grade = static_cast<int>(result[0][1].as<double>() + 0.5);
+            return avg_grade;
+        } else {
+            return -1; // No results found
+        }
+
+    } catch (const pqxx::sql_error &e) {
+        RCLCPP_ERROR(logger_, "[DBS] get final course grade failed: %s", e.what());
+        return -1;
+    } catch (const std::exception &e) {
+        RCLCPP_ERROR(logger_, "[DBS] database error: %s", e.what());
+        return -1;
+    }
+}
+
+std::vector<StudentCourse> DatabaseManager::get_failed_course_results() {
+    std::vector<StudentCourse> failed_courses;
+
+    if (!is_connected()) {
+        return failed_courses;
+    }
+
+    try {
+        pqxx::work txn(*conn_);
+
+        auto result = txn.exec(SQL_SELECT_FAILED_COURSE_RESULTS);
+
+        for (const auto& row : result) {
+            StudentCourse sc;
+            sc.student_name = row[0].as<std::string>();
+            sc.course_name = row[1].as<std::string>();
+
+            failed_courses.push_back(sc);
+        }
+
+        RCLCPP_INFO(logger_, "[DBS] found %zu failed course results", failed_courses.size());
+
+    } catch (const pqxx::sql_error &e) {
+        RCLCPP_ERROR(logger_, "[DBS] 'get failed course results' failed: %s", e.what());
+    } catch (const std::exception &e) {
+        RCLCPP_ERROR(logger_, "[DBS] database error: %s", e.what());
+    }
+
+    return failed_courses;
+}
+
+bool DatabaseManager::update_retake_status(const StudentCourse& sc) {
+    if (!is_connected()) {
+        return false;
+    }
+
+    try {
+        pqxx::work txn(*conn_);
+        txn.exec_params(SQL_UPDATE_RETAKE_STATUS, sc.student_name, sc.course_name);
+        txn.commit();
+        return true;
+    } catch (const pqxx::sql_error &e) {
+        RCLCPP_ERROR(logger_, "[DBS] 'update retake status' failed: %s", e.what());
+        return false;
+    } catch (const std::exception &e) {
+        RCLCPP_ERROR(logger_, "[DBS] database error: %s", e.what());
+        return false;
+    }
+}
+
+} // namespace assignments::one

src/g2_2025_assign1_pkg/src/database/DatabaseManager.hpp

@@ -0,0 +1,64 @@
+/* DatabaseManager.hpp
+ * Database manager for the exam result generator
+ *
+ * Reviewed by: <x>
+ * Changelog:
+ * [23-09-2025] Wessel T: Created database manager class for all DB operations
+ */
+#pragma once
+
+#include <memory>
+#include <vector>
+#include <string>
+#include <pqxx/pqxx>
+#include "rclcpp/rclcpp.hpp"
+
+#include "StudentCourse.hpp"
+#include "config/ConfigManager.hpp"
+
+namespace assignments::one {
+
+class DatabaseManager {
+public:
+    explicit DatabaseManager(rclcpp::Logger logger);
+    ~DatabaseManager() = default;
+
+    bool connect(const std::string& connection_string);
+    virtual bool is_connected() const;
+
+    // Table operations
+    virtual void init_database();
+    void create_tables();
+    void insert_sample_data();
+
+    // Data operations
+    std::vector<StudentCourse> queue_pending_combinations();
+    bool store_exam_result(const std::string& student_name, const std::string& course_name, int grade);
+    bool enroll_student_into_course(const StudentCourse& sc);
+    bool remove_student_from_course(const StudentCourse& sc);
+    virtual bool store_final_course_result(
+        const StudentCourse& sc,
+        int exam_count,
+        int final_grade,
+        bool is_retake
+    );
+
+    int get_final_course_grade(const StudentCourse& sc);
+    std::vector<StudentCourse> get_failed_course_results();
+    bool update_retake_status(const StudentCourse &sc);
+
+private:
+    rclcpp::Logger logger_;
+
+    std::unique_ptr<pqxx::connection> conn_;
+    std::unique_ptr<ConfigManager> config_manager_;
+
+    std::vector<std::pair<std::string, std::string>> sample_students_data_ = {
+        {"Wessel", "ROS2"},
+        {"Vincent", "ROS2"},
+        {"Mohammed", "Differentieren"},
+        {"Tilmann", "Differentieren"},
+    };
+};
+
+} // namespace assignments::one

src/g2_2025_assign1_pkg/src/database/SQLQueries.hpp

@@ -0,0 +1,104 @@
+/* SQLQueries.hpp
+ * SQL query definitions for the exam result generator
+ *
+ * Reviewed by: <x>
+ * Changelog:
+ * [23-09-2025] Wessel T: Created initial database state
+ */
+#pragma once
+
+static const std::string SQL_CREATE_ENROLLMENTS_TABLE = R"(
+    CREATE TABLE IF NOT EXISTS student_enrollments (
+        id SERIAL PRIMARY KEY,
+        student_name VARCHAR(100) NOT NULL,
+        course_name VARCHAR(100) NOT NULL,
+        enrolled_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        UNIQUE(student_name, course_name)
+    );
+)";
+
+static const std::string SQL_CREATE_EXAM_RESULTS = R"(
+    CREATE TABLE IF NOT EXISTS exam_results (
+        id SERIAL PRIMARY KEY,
+        student_name VARCHAR(100) NOT NULL,
+        course_name VARCHAR(100) NOT NULL,
+        exam_grade INTEGER NOT NULL,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+    );
+)";
+// UNIQUE(student_name, course_name)
+
+static const std::string SQL_CREATE_COURSE_RESULTS = R"(
+    CREATE TABLE IF NOT EXISTS final_course_results (
+        id SERIAL PRIMARY KEY,
+        student_name VARCHAR(100) NOT NULL,
+        course_name VARCHAR(100) NOT NULL,
+        exam_count INTEGER NOT NULL,
+        final_grade INTEGER NOT NULL,
+        is_retake BOOLEAN DEFAULT FALSE,
+        retake_done BOOLEAN DEFAULT FALSE,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+    );
+)";
+// UNIQUE(student_name, course_name)
+
+static const std::string SQL_SELECT_EXAM_RESULTS_COUNT = R"(
+    SELECT COUNT(*) FROM exam_results
+)";
+
+static const std::string SQL_SELECT_MISSING_RESULTS = R"(
+    SELECT se.student_name, se.course_name
+    FROM student_enrollments se
+    LEFT JOIN final_course_results fcr
+        ON se.student_name = fcr.student_name
+        AND se.course_name = fcr.course_name
+    WHERE fcr.id IS NULL
+)";
+
+static const std::string SQL_SELECT_STUDENT_EXAM_RESULTS = R"(
+    SELECT COUNT(*), AVG(exam_grade)
+    FROM exam_results
+    WHERE student_name = $1 AND course_name = $2
+)";
+
+
+static const std::string SQL_SELECT_FAILED_COURSE_RESULTS = R"(
+    SELECT fcr.student_name, fcr.course_name, fcr.final_grade, fcr.exam_count
+    FROM final_course_results fcr
+    WHERE fcr.final_grade < 55 AND fcr.retake_done = FALSE
+)";
+
+static const std::string SQL_INSERT_EXAM_RESULT = R"(
+    INSERT INTO exam_results (student_name, course_name, exam_grade)
+    VALUES ($1, $2, $3)
+)";
+// ON CONFLICT (student_name, course_name)
+// DO UPDATE SET exam_grade = EXCLUDED.exam_grade, created_at = CURRENT_TIMESTAMP
+
+static const std::string SQL_INSERT_STUDENT_ENROLLMENT = R"(
+    INSERT INTO student_enrollments (student_name, course_name)
+    VALUES ($1, $2)
+    ON CONFLICT DO NOTHING
+)";
+
+static const std::string SQL_DELETE_STUDENT_ENROLLMENT = R"(
+    DELETE FROM student_enrollments
+    WHERE student_name = $1 AND course_name = $2
+)";
+
+static const std::string SQL_SELECT_STUDENT_LIST = R"(
+    SELECT COUNT(*) FROM student_enrollments
+)";
+
+static const std::string SQL_UPDATE_RETAKE_STATUS = R"(
+    UPDATE final_course_results
+    SET retake_done = TRUE
+    WHERE student_name = $1 AND course_name = $2 AND retake_done = FALSE
+)";
+
+static const std::string SQL_INSERT_FINAL_COURSE_RESULT = R"(
+    INSERT INTO final_course_results (student_name, course_name, exam_count, final_grade, is_retake)
+    VALUES ($1, $2, $3, $4, $5)
+)";
+// ON CONFLICT (student_name, course_name)
+// DO UPDATE SET exam_count = EXCLUDED.exam_count, final_grade = EXCLUDED.final_grade, created_at = CURRENT_TIMESTAMP

src/g2_2025_assign1_pkg/src/database/StudentCourse.hpp

@@ -0,0 +1,35 @@
+/* StudentCourse.hpp
+ * Data structure for student-course combinations
+ *
+ * Reviewed by: <x>
+ * Changelog:
+ * [23-09-2025] Wessel T: Created initial structure
+ */
+#pragma once
+
+#include <string>
+
+namespace assignments::one {
+
+struct StudentCourse {
+    std::string student_name;
+    std::string course_name;
+
+    bool operator==(const StudentCourse& other) const {
+        return student_name == other.student_name && course_name == other.course_name;
+    }
+
+    bool operator<(const StudentCourse& other) const {
+        return student_name < other.student_name
+            || (student_name == other.student_name
+                && course_name < other.course_name);
+    }
+
+    bool operator!=(const StudentCourse& other) const {
+        return !(*this == other);
+    }
+};
+
+typedef std::map<StudentCourse, std::vector<int>> StudentCourseResultMap;
+
+} // namespace assignments::one

src/g2_2025_assign1_pkg/src/g2_2025_exam_result_generator_node/Main.cpp

@@ -7,12 +7,12 @@
  */
 
 #include "rclcpp/rclcpp.hpp"
-#include "nodes/IMUDatabaseWriter.hpp"
+#include "nodes/ExamResultGenerator.hpp"
 
 int main(int argc, char *argv[]) {
     rclcpp::init(argc, argv);
 
-    auto node = std::make_shared<assignments::two::imu_database_writer::IMUDatabaseWriter>();
+    auto node = std::make_shared<assignments::one::g2_2025_exam_result_generator_node::ExamResultGenerator>();
 
     rclcpp::spin(node);
     rclcpp::shutdown();

src/g2_2025_assign1_pkg/src/g2_2025_exam_result_generator_node/nodes/ExamResultGenerator.cpp

@@ -0,0 +1,119 @@
+#include "ExamResultGenerator.hpp"
+
+namespace assignments::one::g2_2025_exam_result_generator_node {
+
+ExamResultGenerator::ExamResultGenerator()
+    : Node("g2_2025_exam_result_generator_node"),
+    gen_(rd_()),
+    grade_dist_(10, 100)
+{
+    this->declare_parameter("delay_between_grades_ms", 2000);
+    int delay_ms = this->get_parameter("delay_between_grades_ms").as_int();
+    delay_between_grades_ = std::chrono::milliseconds(delay_ms);
+
+    db_manager_ = std::make_unique<DatabaseManager>(this->get_logger());
+
+    // Load initial student/course combinations from database
+    queue_pending_combinations();
+
+    // Create publisher for exam results
+    exam_publisher_ = this->create_publisher<g2_2025_assign1_interfaces_pkg::msg::Exam>("exam_results", 10);
+
+    // Create subscriber for adding/removing student/course combinations
+    student_subscriber_ = this->create_subscription<g2_2025_assign1_interfaces_pkg::msg::Student>(
+        "student_course_management", 10,
+        std::bind(
+            &ExamResultGenerator::student_management_callback,
+            this,
+            std::placeholders::_1
+        )
+    );
+
+    // Create timer to generate random exam results every 2 seconds
+    timer_ = this->create_wall_timer(
+        delay_between_grades_,
+        std::bind(&ExamResultGenerator::generate_random_result, this)
+    );
+
+    RCLCPP_INFO(this->get_logger(),
+        "g2_2025_exam_result_generator_node started, %zu pending operations",
+        operations_queue_.size()
+    );
+}
+
+void ExamResultGenerator::queue_pending_combinations() {
+    if (!db_manager_ || !db_manager_->is_connected()) return;
+
+    operations_queue_ = db_manager_->queue_pending_combinations();
+}
+
+void ExamResultGenerator::generate_random_result() {
+    if (operations_queue_.empty()) {
+        RCLCPP_WARN_THROTTLE(this->get_logger(), *this->get_clock(), 10000, "queue is empty");
+        return;
+    }
+
+    if (!db_manager_ || !db_manager_->is_connected()) {
+        RCLCPP_WARN(this->get_logger(), "no database connection");
+        return;
+    }
+
+    // Select random student/course combination
+    std::uniform_int_distribution<> index_dist(0, operations_queue_.size() - 1);
+    int random_index = index_dist(gen_);
+    auto selected = operations_queue_[random_index];
+
+    int grade = grade_dist_(gen_);
+
+    db_manager_->store_exam_result(selected.student_name, selected.course_name, grade);
+
+    // Publish exam result
+    auto exam_msg = g2_2025_assign1_interfaces_pkg::msg::Exam();
+    exam_msg.student_name = selected.student_name;
+    exam_msg.course_name = selected.course_name;
+    exam_msg.result = grade;
+    exam_msg.timestamp = this->get_clock()->now();
+
+    exam_publisher_->publish(exam_msg);
+
+    RCLCPP_INFO(this->get_logger(),
+        "generated grade: (%d) %s in %s",
+        grade, selected.student_name.c_str(), selected.course_name.c_str()
+    );
+}
+
+void ExamResultGenerator::student_management_callback(const g2_2025_assign1_interfaces_pkg::msg::Student::SharedPtr msg) {
+    StudentCourse sc;
+    sc.student_name = msg->student_name;
+    sc.course_name = msg->course_name;
+
+    auto it = std::find(operations_queue_.begin(), operations_queue_.end(), sc);
+
+    if (it != operations_queue_.end()) {
+        operations_queue_.erase(it);
+        db_manager_->remove_student_from_course(sc);
+        RCLCPP_INFO(this->get_logger(), "removed from queue: %s - %s",
+            sc.student_name.c_str(), sc.course_name.c_str()
+        );
+    } else {
+        add_student_course_combination(sc);
+        RCLCPP_INFO(this->get_logger(), "added to queue: %s - %s",
+            sc.student_name.c_str(), sc.course_name.c_str()
+        );
+    }
+}
+
+void ExamResultGenerator::add_student_course_combination(const StudentCourse& sc) {
+    if (!db_manager_ || !db_manager_->is_connected()) {
+        return;
+    }
+
+    if (db_manager_->enroll_student_into_course(sc)) {
+        auto it = std::find(operations_queue_.begin(), operations_queue_.end(), sc);
+        if (it == operations_queue_.end()) {
+            operations_queue_.push_back(sc);
+        }
+    }
+}
+
+} // namespace assignments::one::g2_2025_exam_result_generator_node

src/g2_2025_assign1_pkg/src/g2_2025_exam_result_generator_node/nodes/ExamResultGenerator.hpp

@@ -0,0 +1,55 @@
+/* nodes/ExamResultGenerator.hpp
+ * Exam result generator node for the first assignment of the course EE at InHolland.
+ *
+ * Collects student/course combinations from database where exam results need to be generated.
+ * Randomly generates and broadcasts exam marks (10-100) every 2 seconds.
+ * Can receive messages to add/remove student/course combinations.
+ *
+ * Reviewed by: <x>
+ * Changelog:
+ * [23-09-2025] Wessel T: Initial Implementation
+ * [05-10-2025] Wessel T: Added delay between grades parameter
+ */
+#pragma once
+
+#include <memory>
+#include <string>
+#include <random>
+#include <vector>
+#include <chrono>
+
+#include "rclcpp/rclcpp.hpp"
+#include "g2_2025_assign1_interfaces_pkg/msg/exam.hpp"
+#include "g2_2025_assign1_interfaces_pkg/msg/student.hpp"
+
+#include "database/DatabaseManager.hpp"
+#include "database/StudentCourse.hpp"
+
+namespace assignments::one::g2_2025_exam_result_generator_node {
+
+class ExamResultGenerator : public rclcpp::Node {
+public:
+    ExamResultGenerator();
+
+private:
+    rclcpp::TimerBase::SharedPtr timer_;
+    rclcpp::Publisher<g2_2025_assign1_interfaces_pkg::msg::Exam>::SharedPtr exam_publisher_;
+    rclcpp::Subscription<g2_2025_assign1_interfaces_pkg::msg::Student>::SharedPtr student_subscriber_;
+
+    std::unique_ptr<DatabaseManager> db_manager_;
+
+    std::random_device rd_;
+    std::mt19937 gen_;
+    std::uniform_int_distribution<> grade_dist_;
+
+    std::vector<StudentCourse> operations_queue_;
+
+    std::chrono::milliseconds delay_between_grades_ { 2000 };
+
+    void queue_pending_combinations();
+    void generate_random_result();
+    void student_management_callback(const g2_2025_assign1_interfaces_pkg::msg::Student::SharedPtr msg);
+    void add_student_course_combination(const StudentCourse& sc);
+};
+
+} // namespace assignments::one::g2_2025_exam_result_generator_node

src/g2_2025_assign1_pkg/src/g2_2025_final_grade_determinator_node/main.cpp

@@ -0,0 +1,23 @@
+/* node_template.cpp
+ * Action server node template for ROS2
+ *
+ * Node description:
+ *
+ * Reviewed by: <x>
+ * Changelog:
+ * [04-09-2025] Wessel T: Implement template
+ */
+
+#include "rclcpp/rclcpp.hpp"
+#include "nodes/FinalGradeDeterminator.hpp"
+
+int main(int argc,char *argv[]) {
+    rclcpp::init(argc,argv);
+
+    auto node = std::make_shared<assignments::one::g2_2025_final_grade_determinator_node::FinalGradeDeterminator>();
+
+    rclcpp::spin(node);
+    rclcpp::shutdown();
+
+    return 0;
+}

src/g2_2025_assign1_pkg/src/g2_2025_final_grade_determinator_node/nodes/FinalGradeDeterminator.cpp

@@ -0,0 +1,100 @@
+#include "FinalGradeDeterminator.hpp"
+
+namespace assignments::one::g2_2025_final_grade_determinator_node {
+
+FinalGradeDeterminator::FinalGradeDeterminator(std::unique_ptr<DatabaseManager> db_manager) : Node("g2_2025_final_grade_determinator_node") {
+    this->declare_parameter("grade_collection_amount", 5);
+    grade_collection_amount_ = this->get_parameter("grade_collection_amount").as_int();
+
+    // Make db_manager optional for testing purposes
+    if (db_manager) {
+        db_manager_ = std::move(db_manager);
+    } else {
+        db_manager_ = std::make_unique<DatabaseManager>(this->get_logger());
+    }
+    // Create publisher for exam results
+    student_publisher_ = this->create_publisher<g2_2025_assign1_interfaces_pkg::msg::Student>(
+        "student_course_management", 10
+    );
+
+    // Create subscriber for adding/removing student/course combinations
+    exam_subscriber_ = this->create_subscription<g2_2025_assign1_interfaces_pkg::msg::Exam>(
+        "exam_results", 10,
+        std::bind(
+            &FinalGradeDeterminator::exam_results_callback,
+            this,
+            std::placeholders::_1
+        )
+    );
+
+    exam_service_client_= this->create_client<g2_2025_assign1_interfaces_pkg::srv::Exams>("grade_calculator_service");
+}
+
+void FinalGradeDeterminator::exam_results_callback(
+    const g2_2025_assign1_interfaces_pkg::msg::Exam::SharedPtr msg
+) {
+    student_course_combo_.student_name = msg->student_name;
+    student_course_combo_.course_name = msg->course_name;
+
+    data_map_[student_course_combo_].push_back(msg->result);
+
+    auto grade_collection_as_ulong = static_cast<unsigned long>(grade_collection_amount_);
+    if (data_map_[student_course_combo_].size() == grade_collection_as_ulong) {
+        RCLCPP_INFO(this->get_logger(),
+            "%s // %s: results sent to calculator",
+            msg->student_name.c_str(), msg->course_name.c_str()
+        );
+        grade_calculator_request(student_course_combo_);
+    }
+}
+
+void FinalGradeDeterminator::grade_calculator_request(StudentCourse combo) {
+    if (!exam_service_client_->wait_for_service(std::chrono::seconds(1))) {
+			RCLCPP_WARN(this->get_logger(), "Service not available");
+			return;
+	}
+
+    auto request = std::make_shared<g2_2025_assign1_interfaces_pkg::srv::Exams::Request>();
+    request->course_name = combo.course_name;
+    request->student_name = combo.student_name;
+    request->exam_grades = data_map_[combo];
+
+    // Callback is used due to ros2 not liking passing multiple arguments in async calls
+    auto callback = [this, combo](rclcpp::Client<g2_2025_assign1_interfaces_pkg::srv::Exams>::SharedFuture future)
+    {
+        this->grade_calculator_response(future, combo);
+    };
+    exam_service_client_->async_send_request(request, callback);
+}
+
+void FinalGradeDeterminator::grade_calculator_response(
+    rclcpp::Client<g2_2025_assign1_interfaces_pkg::srv::Exams>::SharedFuture future,
+    StudentCourse studentCourseCombo
+) {
+    if (!db_manager_ || !db_manager_->is_connected()) {
+        RCLCPP_WARN(this->get_logger(), "no database connection");
+        return;
+    }
+
+    auto response = future.get();
+
+    auto student_message = g2_2025_assign1_interfaces_pkg::msg::Student();
+    student_message.student_name = studentCourseCombo.student_name;
+    student_message.course_name = studentCourseCombo.course_name;
+    student_message.timestamp = this->now();
+    student_publisher_->publish(student_message);
+
+    RCLCPP_INFO(this->get_logger(),
+        "%s // %s is %d",
+        studentCourseCombo.student_name.c_str(), studentCourseCombo.course_name.c_str(), response->result
+    );
+
+    db_manager_->store_final_course_result(
+        studentCourseCombo,
+        grade_collection_amount_,
+        response->result,
+        false
+    );
+}
+
+} // namespace assignments::one::g2_2025_final_grade_determinator_node

src/g2_2025_assign1_pkg/src/g2_2025_final_grade_determinator_node/nodes/FinalGradeDeterminator.hpp

@@ -0,0 +1,44 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <random>
+#include <vector>
+#include <chrono>
+
+#include "rclcpp/rclcpp.hpp"
+#include "g2_2025_assign1_interfaces_pkg/msg/exam.hpp"
+#include "g2_2025_assign1_interfaces_pkg/msg/student.hpp"
+#include "g2_2025_assign1_interfaces_pkg/srv/exams.hpp"
+
+#include "database/DatabaseManager.hpp"
+#include "database/StudentCourse.hpp"
+
+namespace assignments::one::g2_2025_final_grade_determinator_node {
+
+class FinalGradeDeterminator : public rclcpp::Node {
+public:
+    FinalGradeDeterminator(std::unique_ptr<DatabaseManager> db_manager = nullptr);
+private:
+    rclcpp::Subscription<g2_2025_assign1_interfaces_pkg::msg::Exam>::SharedPtr exam_subscriber_;
+    rclcpp::Publisher<g2_2025_assign1_interfaces_pkg::msg::Student>::SharedPtr student_publisher_;
+
+    rclcpp::Client<g2_2025_assign1_interfaces_pkg::srv::Exams>::SharedPtr exam_service_client_;
+
+    std::unique_ptr<DatabaseManager> db_manager_;
+
+    StudentCourse student_course_combo_;
+    StudentCourseResultMap data_map_;
+
+    // Params
+    int grade_collection_amount_;
+
+    void grade_calculator_request(StudentCourse combo);
+    void exam_results_callback(const g2_2025_assign1_interfaces_pkg::msg::Exam::SharedPtr msg);
+    void grade_calculator_response(
+        rclcpp::Client<g2_2025_assign1_interfaces_pkg::srv::Exams>::SharedFuture future,
+        StudentCourse studentCourseCombo
+    );
+};
+
+} // namespace assignments::one::g2_2025_final_grade_determinator_node

src/g2_2025_assign1_pkg/src/g2_2025_grade_calculator_node/main.cpp

@@ -0,0 +1,25 @@
+/* node_template.cpp
+ * Action server node template for ROS2
+ *
+ * Node description:
+ * Template action server that demonstrates action server implementation
+ * with goal handling, feedback publishing, and cancellation support
+ *
+ * Reviewed by: <x>
+ * Changelog:
+ * [04-09-2025] Wessel T: Implement template
+ */
+
+#include "rclcpp/rclcpp.hpp"
+#include "nodes/GradeCalculator.hpp"
+
+int main(int argc,char *argv[]) {
+    rclcpp::init(argc,argv);
+
+    auto node = std::make_shared<assignments::one::g2_2025_grade_calculator_node::GradeCalculator>();
+
+    rclcpp::spin(node);
+    rclcpp::shutdown();
+
+    return 0;
+}

src/g2_2025_assign1_pkg/src/g2_2025_grade_calculator_node/nodes/GradeCalculator.cpp

@@ -0,0 +1,48 @@
+#include "GradeCalculator.hpp"
+
+namespace assignments::one::g2_2025_grade_calculator_node {
+
+GradeCalculator::GradeCalculator() : Node("g2_2025_grade_calculator_node") {
+    grade_calculator_service_server_ = this->create_service<g2_2025_assign1_interfaces_pkg::srv::Exams>(
+        "grade_calculator_service",
+        std::bind(
+            &GradeCalculator::grade_calculator_callback,
+            this,
+            std::placeholders::_1,
+            std::placeholders::_2
+        )
+    );
+
+    RCLCPP_INFO(this->get_logger(), "Grade calculator service server started");
+}
+
+void GradeCalculator::grade_calculator_callback(
+    const g2_2025_assign1_interfaces_pkg::srv::Exams::Request::SharedPtr request,
+    const g2_2025_assign1_interfaces_pkg::srv::Exams::Response::SharedPtr response
+) {
+    if (request->exam_grades.size() != 0){
+        grades_total_ = std::accumulate(request->exam_grades.begin(), request->exam_grades.end(), 0);
+
+        auto lowercase = request->student_name;
+
+        std::transform(lowercase.begin(), lowercase.end(), lowercase.begin(), ::tolower);
+
+        grade_result_ = (grades_total_) / request->exam_grades.size();
+
+        if (lowercase.compare("wessel") == 0){
+            grade_result_ += 10;
+        }
+
+        if (grade_result_ > 100) {
+            grade_result_ = 100;
+        } else if (grade_result_ < 10){
+            grade_result_ = 10;
+        }
+    }
+
+    response->result = grade_result_;
+}
+
+} // namespace assignments::one::g2_2025_grade_calculator_node
+
+

src/g2_2025_assign1_pkg/src/g2_2025_grade_calculator_node/nodes/GradeCalculator.hpp

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <random>
+#include <vector>
+
+#include "rclcpp/rclcpp.hpp"
+#include "g2_2025_assign1_interfaces_pkg/msg/exam.hpp"
+#include "g2_2025_assign1_interfaces_pkg/msg/student.hpp"
+#include "g2_2025_assign1_interfaces_pkg/srv/exams.hpp"
+
+
+namespace assignments::one::g2_2025_grade_calculator_node {
+
+class GradeCalculator : public rclcpp::Node {
+public:
+    GradeCalculator();
+private:
+    rclcpp::Service<g2_2025_assign1_interfaces_pkg::srv::Exams>::SharedPtr grade_calculator_service_server_;
+
+    int grades_total_;
+    int grade_result_ = 0;
+
+    void grade_calculator_callback(
+        const g2_2025_assign1_interfaces_pkg::srv::Exams::Request::SharedPtr request,
+        const g2_2025_assign1_interfaces_pkg::srv::Exams::Response::SharedPtr response
+    );
+};
+
+}

src/g2_2025_assign1_pkg/src/g2_2025_retake_grade_determinator_node/main.cpp

@@ -0,0 +1,26 @@
+/* node_template.cpp
+ * Action server node template for ROS2
+ *
+ * Node description:
+ * Template action server that demonstrates action server implementation
+ * with goal handling, feedback publishing, and cancellation support
+ *
+ * Reviewed by: <x>
+ * Changelog:
+ * [04-09-2025] Wessel T: Implement template
+ */
+
+#include "rclcpp/rclcpp.hpp"
+
+#include "nodes/RetakeGradeDeterminator.hpp"
+
+int main(int argc,char *argv[]) {
+    rclcpp::init(argc,argv);
+
+    auto node = std::make_shared<assignments::one::g2_2025_retake_grade_determinator_node::RetakeGradeDeterminator>();
+
+    rclcpp::spin(node);
+    rclcpp::shutdown();
+
+    return 0;
+}

src/g2_2025_assign1_pkg/src/g2_2025_retake_grade_determinator_node/nodes/RetakeGradeDeterminator.cpp

@@ -0,0 +1,161 @@
+#include "RetakeGradeDeterminator.hpp"
+
+namespace assignments::one::g2_2025_retake_grade_determinator_node {
+
+RetakeGradeDeterminator::RetakeGradeDeterminator(std::unique_ptr<DatabaseManager> db_manager) : Node("g2_2025_retake_grade_determinator_node") {
+    this->declare_parameter("grade_collection_amount", 5);
+    grade_collection_amount_ = this->get_parameter("grade_collection_amount").as_int();
+
+    // Make db_manager optional for testing purposes
+    if (db_manager) {
+        db_manager_ = std::move(db_manager);
+    } else {
+        db_manager_ = std::make_unique<DatabaseManager>(this->get_logger());
+    }
+    // Create publisher for exam results
+    student_publisher_ = this->create_publisher<g2_2025_assign1_interfaces_pkg::msg::Student>(
+        "student_course_management", 10
+    );
+
+    // Create subscriber for adding/removing student/course combinations
+    exam_subscriber_ = this->create_subscription<g2_2025_assign1_interfaces_pkg::msg::Exam>(
+        "exam_results", 10,
+        std::bind(
+            &RetakeGradeDeterminator::exam_results_callback,
+            this,
+            std::placeholders::_1
+        )
+    );
+
+    exam_service_client_ = this->create_client<g2_2025_assign1_interfaces_pkg::srv::Exams>("grade_calculator_service");
+
+    // Create action server for retake requests
+    callback_group_ = this->create_callback_group(rclcpp::CallbackGroupType::Reentrant);
+    retake_actionserver_ = rclcpp_action::create_server<g2_2025_assign1_interfaces_pkg::action::Retake>(
+        this,
+        "retake_action",
+        std::bind(&RetakeGradeDeterminator::goal_callback, this, std::placeholders::_1, std::placeholders::_2),
+        std::bind(&RetakeGradeDeterminator::cancel_callback, this, std::placeholders::_1),
+        std::bind(&RetakeGradeDeterminator::spawn_callback_thread, this, std::placeholders::_1),
+        rcl_action_server_get_default_options(),
+        callback_group_
+    );
+
+    RCLCPP_INFO(this->get_logger(), "Action server has been started.");
+}
+
+void RetakeGradeDeterminator::exam_results_callback(
+    const g2_2025_assign1_interfaces_pkg::msg::Exam::SharedPtr msg
+) {
+    if (retake_allowed_) {
+        student_course_combo_.student_name = msg->student_name;
+        student_course_combo_.course_name = msg->course_name;
+
+        data_map_[student_course_combo_].push_back(msg->result);
+
+        auto grade_collection_as_ulong = static_cast<unsigned long>(grade_collection_amount_);
+        if (data_map_[student_course_combo_].size() == grade_collection_as_ulong) {
+            RCLCPP_INFO(this->get_logger(),
+                "%s // %s: results sent to calculator",
+                msg->student_name.c_str(), msg->course_name.c_str()
+            );
+            grade_calculator_request(student_course_combo_);
+        }
+    }
+}
+
+void RetakeGradeDeterminator::grade_calculator_request(StudentCourse combo) {
+    if (!exam_service_client_->wait_for_service(std::chrono::seconds(1))) {
+        RCLCPP_WARN(this->get_logger(), "Service not available");
+        return;
+    }
+
+    auto request = std::make_shared<g2_2025_assign1_interfaces_pkg::srv::Exams::Request>();
+    request->course_name = combo.course_name;
+    request->student_name = combo.student_name;
+    request->exam_grades = data_map_[combo];
+
+    // Callback is used due to ros2 not liking passing multiple arguments in async calls
+    auto callback = [this, combo](rclcpp::Client<g2_2025_assign1_interfaces_pkg::srv::Exams>::SharedFuture future) {
+        this->grade_calculator_response(future, combo);
+        };
+    exam_service_client_->async_send_request(request, callback);
+}
+
+void RetakeGradeDeterminator::grade_calculator_response(
+    rclcpp::Client<g2_2025_assign1_interfaces_pkg::srv::Exams>::SharedFuture future,
+    StudentCourse studentCourseCombo
+) {
+    if (!db_manager_ || !db_manager_->is_connected()) {
+        RCLCPP_WARN(this->get_logger(), "no database connection");
+        return;
+    }
+    data_map_[studentCourseCombo].clear();
+    db_manager_->update_retake_status(studentCourseCombo);
+
+    auto response = future.get();
+
+    auto student_message = g2_2025_assign1_interfaces_pkg::msg::Student();
+    student_message.student_name = studentCourseCombo.student_name;
+    student_message.course_name = studentCourseCombo.course_name;
+    student_message.timestamp = this->now();
+    student_publisher_->publish(student_message);
+
+    RCLCPP_INFO(this->get_logger(),
+        "%s // %s is %d",
+        studentCourseCombo.student_name.c_str(), studentCourseCombo.course_name.c_str(), response->result
+    );
+
+    db_manager_->store_final_course_result(
+        studentCourseCombo,
+        grade_collection_amount_,
+        response->result,
+        true
+    );
+}
+
+rclcpp_action::GoalResponse RetakeGradeDeterminator::goal_callback(
+    const rclcpp_action::GoalUUID& uuid,
+    std::shared_ptr<const g2_2025_assign1_interfaces_pkg::action::Retake::Goal> goal
+) {
+    (void)uuid;
+    RCLCPP_INFO(this->get_logger(),
+        "Received retake goal request for student: %s, course: %s",
+        goal->student_name.c_str(), goal->course_name.c_str());
+
+    RCLCPP_INFO(this->get_logger(), "Retake goal accepted");
+    return rclcpp_action::GoalResponse::ACCEPT_AND_EXECUTE;
+}
+
+rclcpp_action::CancelResponse RetakeGradeDeterminator::cancel_callback(
+    const std::shared_ptr<rclcpp_action::ServerGoalHandle<g2_2025_assign1_interfaces_pkg::action::Retake>> goal_handle
+) {
+    (void)goal_handle;
+    RCLCPP_INFO(this->get_logger(), "Received request to cancel retake goal");
+    return rclcpp_action::CancelResponse::ACCEPT;
+}
+
+void RetakeGradeDeterminator::spawn_callback_thread(
+    const std::shared_ptr<rclcpp_action::ServerGoalHandle<g2_2025_assign1_interfaces_pkg::action::Retake>> goal_handle
+) { // Spawn a new thread to prevent blocking the executor
+    std::thread{std::bind(&RetakeGradeDeterminator::async_execute_callback_thread, this, std::placeholders::_1), goal_handle}.detach();
+}
+
+void RetakeGradeDeterminator::async_execute_callback_thread(
+    const std::shared_ptr<rclcpp_action::ServerGoalHandle<g2_2025_assign1_interfaces_pkg::action::Retake>> goal_handle
+) {
+    retake_allowed_ = true;
+    RCLCPP_INFO(this->get_logger(), "Executing retake action for %s // %s", goal_handle->get_goal()->student_name.c_str(), goal_handle->get_goal()->course_name.c_str());
+
+    auto student_message = g2_2025_assign1_interfaces_pkg::msg::Student();
+    student_message.student_name = goal_handle->get_goal()->student_name;
+    student_message.course_name = goal_handle->get_goal()->course_name;
+    student_message.timestamp = this->now();
+    student_publisher_->publish(student_message);
+
+    auto result = std::make_shared<g2_2025_assign1_interfaces_pkg::action::Retake::Result>();
+    result->result = 0.0;
+    goal_handle->succeed(result);
+}
+
+} // namespace assignments::one::g2_2025_retake_grade_determinator_node

src/g2_2025_assign1_pkg/src/g2_2025_retake_grade_determinator_node/nodes/RetakeGradeDeterminator.hpp

@@ -0,0 +1,61 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <random>
+#include <vector>
+#include <chrono>
+
+#include "rclcpp/rclcpp.hpp"
+#include "rclcpp_action/rclcpp_action.hpp"
+
+#include "g2_2025_assign1_interfaces_pkg/msg/exam.hpp"
+#include "g2_2025_assign1_interfaces_pkg/msg/student.hpp"
+#include "g2_2025_assign1_interfaces_pkg/srv/exams.hpp"
+#include "g2_2025_assign1_interfaces_pkg/action/retake.hpp"
+
+#include "database/DatabaseManager.hpp"
+#include "database/StudentCourse.hpp"
+
+namespace assignments::one::g2_2025_retake_grade_determinator_node {
+
+class RetakeGradeDeterminator : public rclcpp::Node {
+public:
+    RetakeGradeDeterminator(std::unique_ptr<DatabaseManager> db_manager = nullptr);
+private:
+    rclcpp::Subscription<g2_2025_assign1_interfaces_pkg::msg::Exam>::SharedPtr exam_subscriber_;
+    rclcpp::Publisher<g2_2025_assign1_interfaces_pkg::msg::Student>::SharedPtr student_publisher_;
+
+    rclcpp_action::Server<g2_2025_assign1_interfaces_pkg::action::Retake>::SharedPtr retake_actionserver_;
+    rclcpp::CallbackGroup::SharedPtr callback_group_;
+
+    rclcpp::Client<g2_2025_assign1_interfaces_pkg::srv::Exams>::SharedPtr exam_service_client_;
+
+    std::unique_ptr<DatabaseManager> db_manager_;
+
+    StudentCourse student_course_combo_;
+    StudentCourseResultMap data_map_;
+
+    // Params
+    int grade_collection_amount_;
+    bool retake_allowed_ = false;
+
+    void grade_calculator_request(StudentCourse combo);
+    void exam_results_callback(const g2_2025_assign1_interfaces_pkg::msg::Exam::SharedPtr msg);
+    void grade_calculator_response(
+        rclcpp::Client<g2_2025_assign1_interfaces_pkg::srv::Exams>::SharedFuture future,
+        StudentCourse studentCourseCombo
+    );
+
+    rclcpp_action::GoalResponse goal_callback(
+        const rclcpp_action::GoalUUID & uuid,
+        std::shared_ptr<const g2_2025_assign1_interfaces_pkg::action::Retake::Goal> goal);
+
+    rclcpp_action::CancelResponse cancel_callback(
+        const std::shared_ptr<rclcpp_action::ServerGoalHandle<g2_2025_assign1_interfaces_pkg::action::Retake>> goal_handle);
+
+    void spawn_callback_thread(const std::shared_ptr<rclcpp_action::ServerGoalHandle<g2_2025_assign1_interfaces_pkg::action::Retake>> goal_handle);
+    void async_execute_callback_thread(const std::shared_ptr<rclcpp_action::ServerGoalHandle<g2_2025_assign1_interfaces_pkg::action::Retake>> goal_handle);
+};
+
+} // namespace assignments::one::g2_2025_retake_grade_determinator_node

src/g2_2025_assign1_pkg/src/g2_2025_retake_scheduler_node/main.cpp

@@ -0,0 +1,29 @@
+/* node_template.cpp
+ * Action server node template for ROS2
+ *
+ * Node description:
+ * Template action server that demonstrates action server implementation
+ * with goal handling, feedback publishing, and cancellation support
+ *
+ * Reviewed by: <x>
+ * Changelog:
+ * [04-09-2025] Wessel T: Implement template
+ */
+
+#include <cstdlib>
+
+#include "rclcpp/rclcpp.hpp"
+#include "nodes/RetakeScheduler.hpp"
+
+
+
+int main(int argc,char *argv[]) {
+    rclcpp::init(argc,argv);
+
+    auto node = std::make_shared<assignments::one::g2_2025_retake_scheduler_node::RetakeScheduler>();
+
+    rclcpp::spin(node);
+    rclcpp::shutdown();
+
+    return 0;
+}

src/g2_2025_assign1_pkg/src/g2_2025_retake_scheduler_node/nodes/RetakeScheduler.cpp

@@ -0,0 +1,104 @@
+#include "RetakeScheduler.hpp"
+
+namespace assignments::one::g2_2025_retake_scheduler_node {
+
+RetakeScheduler::RetakeScheduler(std::unique_ptr<DatabaseManager> db_manager) : Node("g2_2025_retake_scheduler_node") {
+    this->declare_parameter("retake_check_interval_sec", 120); // Default to 120 seconds
+    retake_check_interval_ = this->get_parameter("retake_check_interval_sec").as_int();
+
+    // Make db_manager optional for testing purposes
+    if (db_manager) {
+        db_manager_ = std::move(db_manager);
+    } else {
+        db_manager_ = std::make_unique<DatabaseManager>(this->get_logger());
+    }
+    // Create action client to communicate with RetakeGradeDeterminator
+    retake_action_client_ = rclcpp_action::create_client<RetakeAction>(this, "retake_action");
+
+    // Check for failing students periodically
+    timer_ = this->create_wall_timer(
+        std::chrono::seconds(retake_check_interval_),
+        std::bind(&RetakeScheduler::check_failing_students, this)
+    );
+}
+
+void RetakeScheduler::check_failing_students() {
+    RCLCPP_INFO(this->get_logger(), "Checking for failing students...");
+
+    std::vector<StudentCourse> failing_students = db_manager_->get_failed_course_results();
+    if (failing_students.empty()) {
+        RCLCPP_INFO(this->get_logger(), "No failing students found.");
+        return;
+    }
+
+    for (const auto& student_course_combo : failing_students) {
+        send_retake_request(student_course_combo);
+    }
+}
+
+void RetakeScheduler::send_retake_request(StudentCourse student_course_combo) {
+    if (!retake_action_client_->wait_for_action_server(std::chrono::seconds(5))) {
+        RCLCPP_ERROR(this->get_logger(), "Retake action server not available after waiting");
+        return;
+    }
+
+    auto goal_msg = RetakeAction::Goal();
+    goal_msg.student_name = student_course_combo.student_name;
+    goal_msg.course_name = student_course_combo.course_name;
+
+    RCLCPP_INFO(this->get_logger(), "Sending retake request for %s // %s", student_course_combo.student_name.c_str(), student_course_combo.course_name.c_str());
+
+    auto send_goal_options = rclcpp_action::Client<RetakeAction>::SendGoalOptions();
+    send_goal_options.goal_response_callback = std::bind(&RetakeScheduler::request_response_callback, this, std::placeholders::_1);
+    send_goal_options.result_callback = std::bind(&RetakeScheduler::request_result_callback, this, std::placeholders::_1);
+    send_goal_options.feedback_callback = std::bind(&RetakeScheduler::request_feedback_callback, this, std::placeholders::_1, std::placeholders::_2);
+
+    retake_action_client_->async_send_goal(goal_msg, send_goal_options);
+
+    RCLCPP_INFO(this->get_logger(), "Retake request sent.");
+}
+
+void RetakeScheduler::cancel_retake_request() {
+    retake_action_client_->async_cancel_all_goals();
+    RCLCPP_INFO(this->get_logger(), "Sent cancel request for all retake goals.");
+}
+
+void RetakeScheduler::request_response_callback(
+    const rclcpp_action::ClientGoalHandle<RetakeAction>::SharedPtr &goal_handle
+) {
+    if (!goal_handle) {
+        RCLCPP_ERROR(this->get_logger(), "Retake goal was rejected by server");
+    } else {
+        RCLCPP_INFO(this->get_logger(), "Retake goal accepted by server, waiting for result");
+    }
+}
+
+void RetakeScheduler::request_result_callback(
+    const rclcpp_action::ClientGoalHandle<RetakeAction>::WrappedResult &result
+) {
+    switch (result.code) {
+        case rclcpp_action::ResultCode::SUCCEEDED:
+            RCLCPP_INFO(this->get_logger(), "Retake goal succeeded");
+            break;
+        case rclcpp_action::ResultCode::ABORTED:
+            RCLCPP_ERROR(this->get_logger(), "Retake goal was aborted");
+            return;
+        case rclcpp_action::ResultCode::CANCELED:
+            RCLCPP_ERROR(this->get_logger(), "Retake goal was canceled");
+            return;
+        default:
+            RCLCPP_ERROR(this->get_logger(), "Unknown result code");
+            return;
+    }
+    RCLCPP_INFO(this->get_logger(), "Retake result received: %.2f", result.result->result);
+}
+
+void RetakeScheduler::request_feedback_callback(
+    rclcpp_action::ClientGoalHandle<RetakeAction>::SharedPtr goal_handle,
+    const std::shared_ptr<const RetakeAction::Feedback> feedback
+) {
+    (void)goal_handle;
+    RCLCPP_INFO(this->get_logger(), "Received feedback: %s", feedback->status.c_str());
+}
+
+} // namespace assignments::one::g2_2025_retake_scheduler_node

src/g2_2025_assign1_pkg/src/g2_2025_retake_scheduler_node/nodes/RetakeScheduler.hpp

@@ -0,0 +1,49 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+#include <chrono>
+
+#include "rclcpp/rclcpp.hpp"
+#include "rclcpp_action/rclcpp_action.hpp"
+#include "g2_2025_assign1_interfaces_pkg/action/retake.hpp"
+
+#include "database/DatabaseManager.hpp"
+#include "database/StudentCourse.hpp"
+
+namespace assignments::one::g2_2025_retake_scheduler_node {
+
+class RetakeScheduler : public rclcpp::Node {
+public:
+    RetakeScheduler(std::unique_ptr<DatabaseManager> db_manager = nullptr);
+
+private:
+    rclcpp::TimerBase::SharedPtr timer_;
+    std::unique_ptr<DatabaseManager> db_manager_;
+
+    using RetakeAction = g2_2025_assign1_interfaces_pkg::action::Retake;
+    rclcpp_action::Client<RetakeAction>::SharedPtr retake_action_client_;
+
+    int retake_check_interval_;
+
+    void send_retake_request(StudentCourse combo);
+    void cancel_retake_request();
+
+    void check_failing_students();
+
+    void request_response_callback(
+        const rclcpp_action::ClientGoalHandle<RetakeAction>::SharedPtr &goal_handle
+    );
+
+    void request_result_callback(
+        const rclcpp_action::ClientGoalHandle<RetakeAction>::WrappedResult &result
+    );
+
+    void request_feedback_callback(
+        rclcpp_action::ClientGoalHandle<RetakeAction>::SharedPtr goal_handle,
+        const std::shared_ptr<const RetakeAction::Feedback> feedback
+    );
+};
+
+} // namespace assignments::one::g2_2025_retake_scheduler_node

src/g2_2025_assign1_pkg/test/ConfigManager.test.cpp

@@ -5,7 +5,7 @@
 
 #include "config/ConfigManager.hpp"
 
-using namespace assignments::two;
+using namespace assignments::one;
 
 static const std::string TEST_CONFIG_CONTENT = R"(
 [database]
@@ -26,7 +26,7 @@ static const std::string TEST_CONFIG_NO_POOL_CONTENT = R"(
 [database]
 host = "localhost"
 port = 5432
-dbname = "imu_data"
+dbname = "grades"
 user = "postgres"
 password = "postgres"
 )";

src/g2_2025_assign1_pkg/test/DatabaseManager.test.cpp

@@ -0,0 +1,79 @@
+#include <gtest/gtest.h>
+#include <rclcpp/rclcpp.hpp>
+
+#include "database/DatabaseManager.hpp"
+#include "database/StudentCourse.hpp"
+
+using namespace assignments::one;
+
+class DatabaseManagerTest : public ::testing::Test {
+protected:
+    void SetUp() override {
+        rclcpp::init(0, nullptr);
+
+        node_ = std::make_shared<rclcpp::Node>("test_db_node");
+        db_manager_ = std::make_unique<DatabaseManager>(node_->get_logger());
+    }
+
+    void TearDown() override {
+        db_manager_.reset();
+        node_.reset();
+        rclcpp::shutdown();
+    }
+
+    std::shared_ptr<rclcpp::Node> node_;
+    std::unique_ptr<DatabaseManager> db_manager_;
+};
+
+TEST_F(DatabaseManagerTest, ConstructorTest) {
+    // Test DatabaseManager can be constructed
+    ASSERT_NE(db_manager_, nullptr);
+}
+
+TEST_F(DatabaseManagerTest, ConnectionStatusTest) {
+    bool status = db_manager_->is_connected();
+
+    EXPECT_TRUE(status == true || status == false);
+}
+
+TEST_F(DatabaseManagerTest, QueuePendingCombinationsTest) {
+    auto combinations = db_manager_->queue_pending_combinations();
+
+    EXPECT_GE(combinations.size(), 0);
+}
+
+TEST_F(DatabaseManagerTest, StoreExamResultTest) {
+    bool result = db_manager_->store_exam_result("TestStudent", "TestCourse", 85);
+
+    EXPECT_TRUE(result == true || result == false);
+}
+
+TEST_F(DatabaseManagerTest, EnrollStudentTest) {
+    StudentCourse sc;
+    sc.student_name = "TestStudent";
+    sc.course_name = "TestCourse";
+
+    bool result = db_manager_->enroll_student_into_course(sc);
+
+    EXPECT_TRUE(result == true || result == false);
+}
+
+TEST_F(DatabaseManagerTest, GetFinalGradeTest) {
+    StudentCourse sc;
+    sc.student_name = "NonExistentStudent";
+    sc.course_name = "NonExistentCourse";
+
+    int grade = db_manager_->get_final_course_grade(sc);
+
+    EXPECT_EQ(grade, -1);
+}
+
+TEST_F(DatabaseManagerTest, StoreFinalResultTest) {
+    StudentCourse sc;
+    sc.student_name = "TestStudent";
+    sc.course_name = "TestCourse";
+
+    bool result = db_manager_->store_final_course_result(sc, 3, 75, false);
+
+    EXPECT_TRUE(result == true || result == false);
+}

src/g2_2025_assign1_pkg/test/ExamResultGenerator.test.cpp

@@ -0,0 +1,225 @@
+#include <chrono>
+#include <memory>
+#include <rclcpp/rclcpp.hpp>
+#include <gtest/gtest.h>
+
+#include "g2_2025_exam_result_generator_node/nodes/ExamResultGenerator.hpp"
+#include "g2_2025_assign1_interfaces_pkg/msg/exam.hpp"
+#include "g2_2025_assign1_interfaces_pkg/msg/student.hpp"
+
+using namespace std::chrono_literals;
+using namespace assignments::one::g2_2025_exam_result_generator_node;
+
+class ExamResultGeneratorTest : public ::testing::Test {
+protected:
+    void SetUp() override {
+        rclcpp::init(0, nullptr);
+
+        // Create a test subscriber to capture published messages
+        test_node_ = std::make_shared<rclcpp::Node>("test_subscriber_node");
+
+        // Subscriber to capture exam results
+        exam_subscriber_ = test_node_->create_subscription<g2_2025_assign1_interfaces_pkg::msg::Exam>(
+            "exam_results", 10,
+            [this](const g2_2025_assign1_interfaces_pkg::msg::Exam::SharedPtr msg) {
+                received_exam_messages_.push_back(*msg);
+            }
+        );
+
+        // Publisher to send student management messages
+        student_publisher_ = test_node_->create_subscription<g2_2025_assign1_interfaces_pkg::msg::Student>(
+            "student_course_management", 10,
+            [this](const g2_2025_assign1_interfaces_pkg::msg::Student::SharedPtr msg) {
+                received_student_messages_.push_back(*msg);
+            }
+        );
+
+        received_exam_messages_.clear();
+        received_student_messages_.clear();
+    }
+
+    void TearDown() override {
+        exam_result_generator_.reset();
+        test_node_.reset();
+
+        rclcpp::shutdown();
+    }
+
+    void create_exam_result_generator() {
+        exam_result_generator_ = std::make_shared<ExamResultGenerator>();
+    }
+
+    void spin_some_time(std::chrono::milliseconds duration = 100ms) {
+        auto start_time = std::chrono::steady_clock::now();
+
+        while (std::chrono::steady_clock::now() - start_time < duration) {
+            rclcpp::spin_some(test_node_);
+
+            if (exam_result_generator_) {
+                rclcpp::spin_some(exam_result_generator_);
+            }
+
+            std::this_thread::sleep_for(10ms);
+        }
+    }
+
+    std::shared_ptr<rclcpp::Node> test_node_;
+    std::shared_ptr<ExamResultGenerator> exam_result_generator_;
+    rclcpp::Subscription<g2_2025_assign1_interfaces_pkg::msg::Exam>::SharedPtr exam_subscriber_;
+    rclcpp::Subscription<g2_2025_assign1_interfaces_pkg::msg::Student>::SharedPtr student_publisher_;
+
+    std::vector<g2_2025_assign1_interfaces_pkg::msg::Exam> received_exam_messages_;
+    std::vector<g2_2025_assign1_interfaces_pkg::msg::Student> received_student_messages_;
+};
+
+TEST_F(ExamResultGeneratorTest, ConstructorTest) {
+    ASSERT_NO_THROW({
+        create_exam_result_generator();
+    });
+
+    ASSERT_NE(exam_result_generator_, nullptr);
+    EXPECT_TRUE(exam_result_generator_->get_node_base_interface() != nullptr);
+    EXPECT_TRUE(exam_result_generator_->get_node_clock_interface() != nullptr);
+    EXPECT_TRUE(exam_result_generator_->get_node_logging_interface() != nullptr);
+}
+
+TEST_F(ExamResultGeneratorTest, PublisherCreationTest) {
+    create_exam_result_generator();
+
+    // Get topic names and types to verify publisher exists
+    auto topic_names_and_types = exam_result_generator_->get_topic_names_and_types();
+
+    bool exam_results_topic_found = false;
+    for (const auto& [topic_name, topic_types] : topic_names_and_types) {
+        if (topic_name == "/exam_results") {
+            exam_results_topic_found = true;
+            // Check if the topic type includes our Exam message type
+            bool correct_type = false;
+            for (const auto& type : topic_types) {
+                if (type == "g2_2025_assign1_interfaces_pkg/msg/Exam") {
+                    correct_type = true;
+                    break;
+                }
+            }
+
+            EXPECT_TRUE(correct_type) << "exam_results topic should have Exam message type";
+            break;
+        }
+    }
+
+    EXPECT_TRUE(exam_results_topic_found) << "exam_results topic should be published";
+}
+
+TEST_F(ExamResultGeneratorTest, SubscriberCreationTest) {
+    create_exam_result_generator();
+
+    // Get subscription names and types to verify subscriber exists
+    auto topic_names_and_types = exam_result_generator_->get_topic_names_and_types();
+
+    bool student_management_topic_found = false;
+    for (const auto& [topic_name, topic_types] : topic_names_and_types) {
+        if (topic_name == "/student_course_management") {
+            student_management_topic_found = true;
+            // Check if the topic type includes our Student message type
+            bool correct_type = false;
+            for (const auto& type : topic_types) {
+                if (type == "g2_2025_assign1_interfaces_pkg/msg/Student") {
+                    correct_type = true;
+                    break;
+                }
+            }
+            EXPECT_TRUE(correct_type) << "student_course_management topic should have Student message type";
+            break;
+        }
+    }
+
+    EXPECT_TRUE(student_management_topic_found) << "student_course_management topic should be subscribed";
+}
+
+TEST_F(ExamResultGeneratorTest, StudentManagementMessageHandlingTest) {
+    create_exam_result_generator();
+
+    // Create a publisher to send student management messages
+    auto student_mgmt_publisher = test_node_->create_publisher<g2_2025_assign1_interfaces_pkg::msg::Student>(
+        "student_course_management", 10
+    );
+
+    // Allow some time for publisher-subscriber connection
+    spin_some_time(500ms);
+
+    // Create and send a student management message
+    auto student_msg = std::make_shared<g2_2025_assign1_interfaces_pkg::msg::Student>();
+    student_msg->student_name = "Test Student";
+    student_msg->course_name = "Test Course";
+    student_msg->timestamp = test_node_->now();
+
+    student_mgmt_publisher->publish(*student_msg);
+
+    spin_some_time(500ms);
+
+    // Test passes if no crash occurred during message handling
+    SUCCEED();
+}
+
+TEST_F(ExamResultGeneratorTest, MultipleStudentMessagesTest) {
+    create_exam_result_generator();
+
+    auto student_mgmt_publisher = test_node_->create_publisher<g2_2025_assign1_interfaces_pkg::msg::Student>(
+        "student_course_management", 10
+    );
+
+    spin_some_time(500ms);
+
+    // Send multiple student management messages
+    std::vector<std::string> students = {"Alice", "Bob", "Charlie"};
+    std::vector<std::string> courses = {"Math", "Physics", "Chemistry"};
+
+    for (const auto& student : students) {
+        for (const auto& course : courses) {
+            auto msg = std::make_shared<g2_2025_assign1_interfaces_pkg::msg::Student>();
+            msg->student_name = student;
+            msg->course_name = course;
+            msg->timestamp = test_node_->now();
+
+            student_mgmt_publisher->publish(*msg);
+            spin_some_time(50ms);
+        }
+    }
+
+    spin_some_time(1s);
+
+    // Test passes if no crash occurred
+    SUCCEED();
+}
+
+// Test for message content validation (when messages are published)
+TEST_F(ExamResultGeneratorTest, ExamMessageValidationTest) {
+    create_exam_result_generator();
+
+    // Create exam result subscriber to capture messages
+    auto exam_subscriber = test_node_->create_subscription<g2_2025_assign1_interfaces_pkg::msg::Exam>(
+        "exam_results", 10,
+        [this](const g2_2025_assign1_interfaces_pkg::msg::Exam::SharedPtr msg) {
+            received_exam_messages_.push_back(*msg);
+        }
+    );
+
+    spin_some_time(500ms);
+
+    // Spin for several timer cycles to potentially catch exam messages
+    auto start_time = std::chrono::steady_clock::now();
+    while (std::chrono::steady_clock::now() - start_time < 6s) {
+        spin_some_time(100ms);
+
+        for (const auto& exam_msg : received_exam_messages_) {
+            // Validate grade range (should be 10-100)
+            EXPECT_GE(exam_msg.result, 10) << "Grade should be >= 10";
+            EXPECT_LE(exam_msg.result, 100) << "Grade should be <= 100";
+
+            EXPECT_FALSE(exam_msg.course_name.empty()) << "Course name should not be empty";
+        }
+    }
+
+    // Test passes regardless of whether messages were received (depends on database connectivity)
+    SUCCEED();
+}

src/g2_2025_assign1_pkg/test/FinalGradeDeterminator.test.cpp

@@ -0,0 +1,192 @@
+#include <chrono>
+#include <memory>
+#include <rclcpp/rclcpp.hpp>
+#include <gtest/gtest.h>
+
+#include "g2_2025_final_grade_determinator_node/nodes/FinalGradeDeterminator.hpp"
+#include "database/DatabaseManager.hpp"
+#include "g2_2025_assign1_interfaces_pkg/msg/exam.hpp"
+#include "g2_2025_assign1_interfaces_pkg/msg/student.hpp"
+#include "g2_2025_assign1_interfaces_pkg/srv/exams.hpp"
+
+#include "mocks/MockDatabaseManager.hpp"
+
+using namespace std::chrono_literals;
+using namespace assignments::one::g2_2025_final_grade_determinator_node;
+
+class FinalGradeDeterminatorTest : public ::testing::Test {
+protected:
+    void SetUp() override {
+        rclcpp::init(0, nullptr);
+
+        test_node_ = std::make_shared<rclcpp::Node>("test_node");
+
+        // Subscriber to capture student messages
+        student_subscriber_ = test_node_->create_subscription<g2_2025_assign1_interfaces_pkg::msg::Student>(
+            "student_course_management", 10,
+            [this](const g2_2025_assign1_interfaces_pkg::msg::Student::SharedPtr msg) {
+                received_student_messages_.push_back(*msg);
+            }
+        );
+
+        // Publisher to send exam messages
+        exam_publisher_ = test_node_->create_publisher<g2_2025_assign1_interfaces_pkg::msg::Exam>(
+            "exam_results", 10
+        );
+
+        // Mock service server for grade calculator
+        grade_calculator_service_ = test_node_->create_service<g2_2025_assign1_interfaces_pkg::srv::Exams>(
+            "grade_calculator_service",
+            [this](const g2_2025_assign1_interfaces_pkg::srv::Exams::Request::SharedPtr request,
+                g2_2025_assign1_interfaces_pkg::srv::Exams::Response::SharedPtr response) {
+                    service_requests_.push_back(*request);
+                    // Mock calculation - average of grades
+                    int sum = 0;
+                    for (const auto& grade : request->exam_grades) {
+                        sum += grade;
+                    }
+                    response->result = sum / request->exam_grades.size();
+            }
+        );
+
+        received_student_messages_.clear();
+        service_requests_.clear();
+    }
+
+    void TearDown() override {
+        final_grade_determinator_.reset();
+        fake_db_.reset();
+        test_node_.reset();
+        rclcpp::shutdown();
+    }
+
+    void create_final_grade_determinator() {
+        fake_db_ = std::make_unique<assignments::one::MockDatabaseManager>();
+        final_grade_determinator_ = std::make_shared<FinalGradeDeterminator>(std::move(fake_db_));
+    }
+
+    void spin_some_time(std::chrono::milliseconds duration = 100ms) {
+        auto start_time = std::chrono::steady_clock::now();
+
+        while (std::chrono::steady_clock::now() - start_time < duration) {
+            rclcpp::spin_some(test_node_);
+
+            if (final_grade_determinator_) {
+                rclcpp::spin_some(final_grade_determinator_);
+            }
+
+            std::this_thread::sleep_for(10ms);
+        }
+    }
+
+    std::unique_ptr<assignments::one::MockDatabaseManager> fake_db_;
+    std::shared_ptr<rclcpp::Node> test_node_;
+    std::shared_ptr<FinalGradeDeterminator> final_grade_determinator_;
+    rclcpp::Subscription<g2_2025_assign1_interfaces_pkg::msg::Student>::SharedPtr student_subscriber_;
+    rclcpp::Publisher<g2_2025_assign1_interfaces_pkg::msg::Exam>::SharedPtr exam_publisher_;
+    rclcpp::Service<g2_2025_assign1_interfaces_pkg::srv::Exams>::SharedPtr grade_calculator_service_;
+    std::vector<g2_2025_assign1_interfaces_pkg::msg::Student> received_student_messages_;
+    std::vector<g2_2025_assign1_interfaces_pkg::srv::Exams::Request> service_requests_;
+};
+
+// ---- TEST CASES ----
+
+TEST_F(FinalGradeDeterminatorTest, ConstructorTest) {
+    ASSERT_NO_THROW({
+        create_final_grade_determinator();
+    });
+
+    ASSERT_NE(final_grade_determinator_, nullptr);
+}
+
+TEST_F(FinalGradeDeterminatorTest, ExamCollectionTest) {
+    create_final_grade_determinator();
+    spin_some_time(500ms);
+
+    const std::string student_name = "Test Student";
+    const std::string course_name = "Test Course";
+    std::vector<int> grades = { 80, 85, 90, 75, 95 };
+
+    // Send 5 exam results (default collection amount)
+    for (const auto& grade : grades) {
+        auto msg = std::make_shared<g2_2025_assign1_interfaces_pkg::msg::Exam>();
+        msg->student_name = student_name;
+        msg->course_name = course_name;
+        msg->result = grade;
+        msg->timestamp = test_node_->now();
+
+        exam_publisher_->publish(*msg);
+        spin_some_time(50ms);
+    }
+
+    spin_some_time(1s);
+
+    // Verify service request was made
+    ASSERT_FALSE(service_requests_.empty());
+    EXPECT_EQ(service_requests_.back().student_name, student_name);
+    EXPECT_EQ(service_requests_.back().course_name, course_name);
+    EXPECT_EQ(service_requests_.back().exam_grades, grades);
+
+    // Verify student message was published
+    ASSERT_FALSE(received_student_messages_.empty());
+    EXPECT_EQ(received_student_messages_.back().student_name, student_name);
+    EXPECT_EQ(received_student_messages_.back().course_name, course_name);
+}
+
+TEST_F(FinalGradeDeterminatorTest, PartialExamCollectionTest) {
+    create_final_grade_determinator();
+    spin_some_time(500ms);
+
+    // Send only 3 exam results (less than required 5)
+    const std::string student_name = "Test Student";
+    const std::string course_name = "Test Course";
+    std::vector<int> grades = { 80, 85, 90 };
+
+    for (const auto& grade : grades) {
+        auto msg = std::make_shared<g2_2025_assign1_interfaces_pkg::msg::Exam>();
+        msg->student_name = student_name;
+        msg->course_name = course_name;
+        msg->result = grade;
+        msg->timestamp = test_node_->now();
+
+        exam_publisher_->publish(*msg);
+        spin_some_time(50ms);
+    }
+
+    spin_some_time(1s);
+
+    // Verify no service request was made yet
+    EXPECT_TRUE(service_requests_.empty());
+    // Verify no student message was published
+    EXPECT_TRUE(received_student_messages_.empty());
+}
+
+TEST_F(FinalGradeDeterminatorTest, MultipleStudentsTest) {
+    create_final_grade_determinator();
+    spin_some_time(500ms);
+
+    std::vector<std::string> students = { "Alice", "Bob" };
+    const std::string course_name = "Test Course";
+    std::vector<int> grades = { 80, 85, 90, 75, 95 };
+
+    // Send complete set of grades for each student
+    for (const auto& student : students) {
+        for (const auto& grade : grades) {
+            auto msg = std::make_shared<g2_2025_assign1_interfaces_pkg::msg::Exam>();
+            msg->student_name = student;
+            msg->course_name = course_name;
+            msg->result = grade;
+            msg->timestamp = test_node_->now();
+
+            exam_publisher_->publish(*msg);
+            spin_some_time(50ms);
+        }
+    }
+
+    spin_some_time(1s);
+
+    // Verify service requests were made for both students
+    ASSERT_EQ(service_requests_.size(), 2);
+    // Verify student messages were published for both students
+    ASSERT_EQ(received_student_messages_.size(), 2);
+}

src/g2_2025_assign1_pkg/test/GradeCalculator.test.cpp

@@ -0,0 +1,98 @@
+#include <gtest/gtest.h>
+#include <rclcpp/rclcpp.hpp>
+#include <thread>
+#include <g2_2025_assign1_interfaces_pkg/srv/exams.hpp>
+#include "g2_2025_grade_calculator_node/nodes/GradeCalculator.hpp"
+
+using namespace std::chrono_literals;
+using assignments::one::g2_2025_grade_calculator_node::GradeCalculator;
+
+class GradeCalculatorTest : public ::testing::Test
+{
+protected:
+    static void SetUpTestSuite() {
+        int argc = 0;
+        char** argv = nullptr;
+        rclcpp::init(argc, argv);
+    }
+
+    static void TearDownTestSuite() {
+        rclcpp::shutdown();
+    }
+
+    void SetUp() override
+    {
+        // Start GradeCalculator node
+        grade_calculator_node_ = std::make_shared<GradeCalculator>();
+        executor_ = std::make_shared<rclcpp::executors::SingleThreadedExecutor>();
+        executor_->add_node(grade_calculator_node_);
+
+        // Spin in background thread
+        spin_thread_ = std::thread([this]() {
+            executor_->spin();
+        });
+
+        // Create client node
+        client_node_ = rclcpp::Node::make_shared("grade_calculator_test_client");
+        client_ = client_node_->create_client<g2_2025_assign1_interfaces_pkg::srv::Exams>("grade_calculator_service");
+    }
+
+    void TearDown() override
+    {
+        executor_->cancel();
+        if (spin_thread_.joinable()) {
+            spin_thread_.join();
+        }
+
+        grade_calculator_node_.reset();
+        client_.reset();
+        client_node_.reset();
+    }
+
+    int call_service(const std::string& name, const std::vector<int>& grades)
+    {
+        if (!client_->wait_for_service(5s)) {
+            throw std::runtime_error("Service not available");
+        }
+
+        auto request = std::make_shared<g2_2025_assign1_interfaces_pkg::srv::Exams::Request>();
+        request->student_name = name;
+        request->exam_grades = grades;
+
+        auto future = client_->async_send_request(request);
+
+        if (rclcpp::spin_until_future_complete(client_node_, future) == rclcpp::FutureReturnCode::SUCCESS) {
+            return future.get()->result;
+        } else {
+            throw std::runtime_error("Service call failed");
+        }
+    }
+
+    std::shared_ptr<rclcpp::executors::SingleThreadedExecutor> executor_;
+    std::shared_ptr<GradeCalculator> grade_calculator_node_;
+    std::thread spin_thread_;
+    rclcpp::Node::SharedPtr client_node_;
+    rclcpp::Client<g2_2025_assign1_interfaces_pkg::srv::Exams>::SharedPtr client_;
+};
+
+// ---- TEST CASES ----
+
+TEST_F(GradeCalculatorTest, NormalAverage) {
+    EXPECT_EQ(call_service("Alice", { 80, 90, 70 }), 80);
+}
+
+TEST_F(GradeCalculatorTest, WesselBonus) {
+    EXPECT_EQ(call_service("Wessel", { 80, 90, 70 }), 90);
+}
+
+TEST_F(GradeCalculatorTest, wesselBonus) {
+    EXPECT_EQ(call_service("wessel", { 80, 90, 70 }), 90);
+}
+
+TEST_F(GradeCalculatorTest, GradeTooHigh) {
+    EXPECT_EQ(call_service("Wessel", { 100, 100, 100 }), 100);
+}
+
+TEST_F(GradeCalculatorTest, GradeTooLow) {
+    EXPECT_EQ(call_service("Alice", { 0, 0, 0 }), 10);
+}

src/g2_2025_assign1_pkg/test/RetakeGradeDeterminator.test.cpp

@@ -0,0 +1,338 @@
+#include <chrono>
+#include <memory>
+#include <rclcpp/rclcpp.hpp>
+#include <rclcpp_action/rclcpp_action.hpp>
+#include <gtest/gtest.h>
+
+#include "g2_2025_retake_grade_determinator_node/nodes/RetakeGradeDeterminator.hpp"
+#include "database/DatabaseManager.hpp"
+#include "g2_2025_assign1_interfaces_pkg/msg/exam.hpp"
+#include "g2_2025_assign1_interfaces_pkg/msg/student.hpp"
+#include "g2_2025_assign1_interfaces_pkg/srv/exams.hpp"
+#include "g2_2025_assign1_interfaces_pkg/action/retake.hpp"
+
+#include "mocks/MockDatabaseManager.hpp"
+
+using namespace std::chrono_literals;
+using namespace assignments::one::g2_2025_retake_grade_determinator_node;
+
+class RetakeGradeDeterminatorTest : public ::testing::Test {
+protected:
+    void SetUp() override {
+        rclcpp::init(0, nullptr);
+
+        // Create a test node for testing communication
+        test_node_ = std::make_shared<rclcpp::Node>("test_node");
+
+        // Create mock database manager
+        mock_db_ = std::make_unique<assignments::one::MockDatabaseManager>();
+        ptr_mock_db_ = mock_db_.get();
+
+        // Subscriber to capture student management messages
+        student_subscriber_ = test_node_->create_subscription<g2_2025_assign1_interfaces_pkg::msg::Student>(
+            "student_course_management", 10,
+            [this](const g2_2025_assign1_interfaces_pkg::msg::Student::SharedPtr msg) {
+                received_student_messages_.push_back(*msg);
+            }
+        );
+
+        // Publisher to send exam results
+        exam_publisher_ = test_node_->create_publisher<g2_2025_assign1_interfaces_pkg::msg::Exam>(
+            "exam_results", 10
+        );
+
+        // Service server to mock grade calculator
+        grade_calculator_service_ = test_node_->create_service<g2_2025_assign1_interfaces_pkg::srv::Exams>(
+            "grade_calculator_service",
+            [this](const std::shared_ptr<g2_2025_assign1_interfaces_pkg::srv::Exams::Request> request,
+                   std::shared_ptr<g2_2025_assign1_interfaces_pkg::srv::Exams::Response> response) {
+                service_requests_.push_back(*request);
+                response->result = 75;
+            }
+        );
+
+        // Action client to test retake action server
+        retake_action_client_ = rclcpp_action::create_client<g2_2025_assign1_interfaces_pkg::action::Retake>(
+            test_node_, "retake_action"
+        );
+
+        received_student_messages_.clear();
+        service_requests_.clear();
+    }
+
+    void TearDown() override {
+        retake_grade_determinator_.reset();
+        test_node_.reset();
+        rclcpp::shutdown();
+    }
+
+    void create_retake_grade_determinator() {
+        retake_grade_determinator_ = std::make_shared<RetakeGradeDeterminator>(
+            std::move(mock_db_)
+        );
+    }
+
+    void spin_some_time(std::chrono::milliseconds duration = 100ms) {
+        auto start_time = std::chrono::steady_clock::now();
+
+        while (std::chrono::steady_clock::now() - start_time < duration) {
+            rclcpp::spin_some(test_node_);
+
+            if (retake_grade_determinator_) {
+                rclcpp::spin_some(retake_grade_determinator_);
+            }
+
+            std::this_thread::sleep_for(10ms);
+        }
+    }
+
+    std::shared_ptr<rclcpp::Node> test_node_;
+
+    std::unique_ptr<assignments::one::MockDatabaseManager> mock_db_;
+    assignments::one::MockDatabaseManager* ptr_mock_db_;
+    std::shared_ptr<RetakeGradeDeterminator> retake_grade_determinator_;
+
+    rclcpp::Subscription<g2_2025_assign1_interfaces_pkg::msg::Student>::SharedPtr student_subscriber_;
+    rclcpp::Publisher<g2_2025_assign1_interfaces_pkg::msg::Exam>::SharedPtr exam_publisher_;
+    rclcpp::Service<g2_2025_assign1_interfaces_pkg::srv::Exams>::SharedPtr grade_calculator_service_;
+    rclcpp_action::Client<g2_2025_assign1_interfaces_pkg::action::Retake>::SharedPtr retake_action_client_;
+
+    std::vector<g2_2025_assign1_interfaces_pkg::msg::Student> received_student_messages_;
+    std::vector<g2_2025_assign1_interfaces_pkg::srv::Exams::Request> service_requests_;
+};
+
+TEST_F(RetakeGradeDeterminatorTest, ConstructorTest) {
+    ASSERT_NO_THROW(create_retake_grade_determinator());
+
+    ASSERT_NE(retake_grade_determinator_, nullptr);
+}
+
+TEST_F(RetakeGradeDeterminatorTest, PublisherCreationTest) {
+    create_retake_grade_determinator();
+
+    bool student_management_topic_found = false;
+    auto topic_names_and_types = retake_grade_determinator_->get_topic_names_and_types();
+
+    for (const auto& [ topic_name, topic_types ] : topic_names_and_types) {
+        if (topic_name == "/student_course_management") {
+            student_management_topic_found = true;
+            bool correct_type = false;
+
+            for (const auto& type : topic_types) {
+                if (type == "g2_2025_assign1_interfaces_pkg/msg/Student") {
+                    correct_type = true;
+                    break;
+                }
+            }
+
+            EXPECT_TRUE(correct_type)
+                << "student_course_management topic should have Student message type";
+            break;
+        }
+    }
+
+    EXPECT_TRUE(student_management_topic_found)
+        << "student_course_management topic should be published";
+}
+
+TEST_F(RetakeGradeDeterminatorTest, SubscriberCreationTest) {
+    create_retake_grade_determinator();
+
+    bool exam_results_topic_found = false;
+    auto topic_names_and_types = retake_grade_determinator_->get_topic_names_and_types();
+
+    for (const auto& [ topic_name, topic_types ] : topic_names_and_types) {
+        if (topic_name == "/exam_results") {
+            exam_results_topic_found = true;
+            bool correct_type = false;
+
+            for (const auto& type : topic_types) {
+                if (type == "g2_2025_assign1_interfaces_pkg/msg/Exam") {
+                    correct_type = true;
+                    break;
+                }
+            }
+
+            EXPECT_TRUE(correct_type)
+                << "exam_results topic should have Exam message type";
+            break;
+        }
+    }
+
+    EXPECT_TRUE(exam_results_topic_found)
+        << "exam_results topic should be subscribed";
+}
+
+TEST_F(RetakeGradeDeterminatorTest, ActionServerCreationTest) {
+    create_retake_grade_determinator();
+
+    // Allow time for action server to be created
+    spin_some_time(500ms);
+
+    // Check if action client can connect to the server
+    bool server_available = retake_action_client_->wait_for_action_server(
+        std::chrono::seconds(2)
+    );
+
+    EXPECT_TRUE(server_available)
+        << "Retake action server should be available";
+}
+
+TEST_F(RetakeGradeDeterminatorTest, ServiceClientCreationTest) {
+    create_retake_grade_determinator();
+
+    auto service_names_and_types = retake_grade_determinator_->get_service_names_and_types();
+
+    bool grade_calculator_service_found = false;
+    for (const auto& [ service_name, service_types ] : service_names_and_types) {
+        if (service_name == "/grade_calculator_service") {
+            grade_calculator_service_found = true;
+            break;
+        }
+    }
+
+    EXPECT_TRUE(grade_calculator_service_found)
+        << "grade_calculator_service should be available as client";
+}
+
+TEST_F(RetakeGradeDeterminatorTest, ParameterTest) {
+    create_retake_grade_determinator();
+
+    auto param = retake_grade_determinator_->get_parameter("grade_collection_amount");
+    EXPECT_EQ(param.as_int(), 5)
+        << "Default grade_collection_amount should be 5";
+}
+
+TEST_F(RetakeGradeDeterminatorTest, ExamResultsIgnoredWhenRetakeNotAllowed) {
+    create_retake_grade_determinator();
+
+    auto exam_msg = std::make_shared<g2_2025_assign1_interfaces_pkg::msg::Exam>();
+    exam_msg->student_name = "tilmann";
+    exam_msg->course_name = "computeren";
+    exam_msg->result = 85;
+
+    exam_publisher_->publish(*exam_msg);
+    spin_some_time(200ms);
+
+    EXPECT_TRUE(service_requests_.empty())
+        << "No service requests should be made when retake not allowed";
+}
+
+TEST_F(RetakeGradeDeterminatorTest, RetakeActionGoalAcceptance) {
+    create_retake_grade_determinator();
+
+    ASSERT_TRUE(retake_action_client_->wait_for_action_server(std::chrono::seconds(2)));
+
+    auto goal = g2_2025_assign1_interfaces_pkg::action::Retake::Goal();
+    goal.student_name = "tilmann";
+    goal.course_name = "differentieren";
+
+    bool goal_accepted = false;
+    auto send_goal_options = rclcpp_action::Client<g2_2025_assign1_interfaces_pkg::action::Retake>::SendGoalOptions();
+
+    send_goal_options.goal_response_callback =
+        [&goal_accepted](
+            std::shared_ptr<rclcpp_action::ClientGoalHandle<g2_2025_assign1_interfaces_pkg::action::Retake>> goal_handle
+        ) {
+            if (goal_handle) {
+                goal_accepted = true;
+            }
+        };
+
+    retake_action_client_->async_send_goal(goal, send_goal_options);
+    // Give asynchronous action service time to process
+    spin_some_time(500ms);
+
+    EXPECT_TRUE(goal_accepted)
+        << "Retake goal should be accepted";
+    EXPECT_EQ(received_student_messages_.size(), 1)
+        << "Should publish student enrollment message";
+
+    if (!received_student_messages_.empty()) {
+        EXPECT_EQ(received_student_messages_[0].student_name, "tilmann");
+        EXPECT_EQ(received_student_messages_[0].course_name, "differentieren");
+    }
+}
+
+// TEST_F(RetakeGradeDeterminatorTest, ExamResultsProcessingDuringRetake) {
+//     create_retake_grade_determinator();
+
+//     ASSERT_TRUE(retake_action_client_->wait_for_action_server(std::chrono::seconds(2)));
+
+//     auto goal = g2_2025_assign1_interfaces_pkg::action::Retake::Goal();
+//     goal.student_name = "tilmann";
+//     goal.course_name = "differentieren";
+
+//     auto send_goal_options = rclcpp_action::Client<g2_2025_assign1_interfaces_pkg::action::Retake>::SendGoalOptions();
+//     retake_action_client_->async_send_goal(goal, send_goal_options);
+//     spin_some_time(300ms);
+
+//     received_student_messages_.clear();
+
+//     for (int i = 0; i < 5; ++i) {
+//         auto exam_msg = std::make_shared<g2_2025_assign1_interfaces_pkg::msg::Exam>();
+//         exam_msg->student_name = "tilmann";
+//         exam_msg->course_name = "differentieren";
+//         exam_msg->result = 70 + i;
+
+//         exam_publisher_->publish(*exam_msg);
+//     }
+
+//     spin_some_time(500ms);
+
+//     EXPECT_EQ(service_requests_.size(), 1)
+//         << "Should make one service request after collecting required exam results";
+
+//     if (!service_requests_.empty()) {
+//         EXPECT_EQ(service_requests_[0].student_name, "tilmann");
+//         EXPECT_EQ(service_requests_[0].course_name, "differentieren");
+//         EXPECT_EQ(service_requests_[0].exam_grades.size(), 5);
+//     }
+
+//     // Should publish final result
+//     EXPECT_EQ(received_student_messages_.size(), 1)
+//         << "Should publish final student result";
+
+//     // Should store in database with retake flag
+//     EXPECT_EQ(ptr_mock_db_->stored_results.size(), 1);
+//     if (!ptr_mock_db_->stored_results.empty()) {
+//         EXPECT_TRUE(ptr_mock_db_->stored_results[0].is_retake)
+//             << "Should store result with retake flag";
+//         EXPECT_EQ(ptr_mock_db_->stored_results[0].final_grade, 75);
+//     }
+
+//     EXPECT_EQ(ptr_mock_db_->retake_status_updates.size(), 1);
+// }
+
+TEST_F(RetakeGradeDeterminatorTest, PartialExamResultsCollection) {
+    create_retake_grade_determinator();
+
+    // spin_some_time(500ms);
+
+    ASSERT_TRUE(retake_action_client_->wait_for_action_server(std::chrono::seconds(2)));
+
+    auto goal = g2_2025_assign1_interfaces_pkg::action::Retake::Goal();
+    goal.student_name = "tilmann";
+    goal.course_name = "differentieren";
+
+    auto send_goal_options = rclcpp_action::Client<g2_2025_assign1_interfaces_pkg::action::Retake>::SendGoalOptions();
+    retake_action_client_->async_send_goal(goal, send_goal_options);
+    spin_some_time(300ms);
+
+    // Send only 3 out of 5 required exam results
+    for (int i = 0; i < 3; ++i) {
+        auto exam_msg = std::make_shared<g2_2025_assign1_interfaces_pkg::msg::Exam>();
+        exam_msg->student_name = "tilmann";
+        exam_msg->course_name = "differentieren";
+        exam_msg->result = 65 + i;
+
+        exam_publisher_->publish(*exam_msg);
+    }
+
+    spin_some_time(300ms);
+
+    EXPECT_TRUE(service_requests_.empty())
+        << "Should not make service request with insufficient exam results";
+    EXPECT_TRUE(ptr_mock_db_->stored_results.empty())
+        << "Should not store results with insufficient exam results";
+}

src/g2_2025_assign1_pkg/test/RetakeScheduler.test.cpp

@@ -0,0 +1,123 @@
+#include <chrono>
+#include <memory>
+#include <rclcpp/rclcpp.hpp>
+#include <rclcpp_action/rclcpp_action.hpp>
+#include <gtest/gtest.h>
+
+#include "g2_2025_retake_scheduler_node/nodes/RetakeScheduler.hpp"
+#include "database/DatabaseManager.hpp"
+#include "g2_2025_assign1_interfaces_pkg/action/retake.hpp"
+
+#include "mocks/MockDatabaseManager.hpp"
+#include "mocks/MockRetakeActionServer.hpp"
+
+using namespace std::chrono_literals;
+using namespace assignments::one::g2_2025_retake_scheduler_node;
+
+class RetakeSchedulerTest : public ::testing::Test {
+protected:
+    void SetUp() override {
+        rclcpp::init(0, nullptr);
+
+        // Create test node and mock action server
+        test_node_ = std::make_shared<rclcpp::Node>("test_node");
+        mock_action_server_ = std::make_unique<assignments::one::MockRetakeActionServer>(test_node_);
+
+        // Create mock database manager
+        mock_db_ = std::make_unique<assignments::one::MockDatabaseManager>();
+        mock_db_ptr_ = mock_db_.get();
+    }
+
+    void TearDown() override {
+        retake_scheduler_.reset();
+        mock_action_server_.reset();
+        test_node_.reset();
+        rclcpp::shutdown();
+    }
+
+    void create_retake_scheduler() {
+        retake_scheduler_ = std::make_shared<RetakeScheduler>(
+            std::move(mock_db_)
+        );
+    }
+
+    void spin_some_time(std::chrono::milliseconds duration = 100ms) {
+        auto start_time = std::chrono::steady_clock::now();
+
+        while (std::chrono::steady_clock::now() - start_time < duration) {
+            rclcpp::spin_some(test_node_);
+
+            if (retake_scheduler_) {
+                rclcpp::spin_some(retake_scheduler_);
+            }
+
+            std::this_thread::sleep_for(10ms);
+        }
+    }
+
+    std::shared_ptr<rclcpp::Node> test_node_;
+    std::shared_ptr<RetakeScheduler> retake_scheduler_;
+    std::unique_ptr<assignments::one::MockDatabaseManager> mock_db_;
+    assignments::one::MockDatabaseManager* mock_db_ptr_;
+    std::unique_ptr<assignments::one::MockRetakeActionServer> mock_action_server_;
+};
+
+TEST_F(RetakeSchedulerTest, ConstructorTest) {
+    ASSERT_NO_THROW(create_retake_scheduler());
+
+    ASSERT_NE(retake_scheduler_, nullptr);
+}
+
+TEST_F(RetakeSchedulerTest, ActionClientCreationTest) {
+    create_retake_scheduler();
+
+    bool retake_action_found = false;
+    auto service_names_and_types = retake_scheduler_->get_service_names_and_types();
+
+    for (const auto& [ service_name, service_types ] : service_names_and_types) {
+        if (service_name == "/retake_action/_action/cancel_goal" ||
+            service_name == "/retake_action/_action/get_result" ||
+            service_name == "/retake_action/_action/send_goal") {
+            retake_action_found = true;
+            break;
+        }
+    }
+
+    EXPECT_TRUE(retake_action_found)
+        << "Retake action client services should be available";
+}
+
+TEST_F(RetakeSchedulerTest, ParameterTest) {
+    create_retake_scheduler();
+
+    // Test default parameter value
+    auto param = retake_scheduler_->get_parameter("retake_check_interval_sec");
+    EXPECT_EQ(param.as_int(), 120) << "Default retake_check_interval should be 120 seconds";
+}
+
+TEST_F(RetakeSchedulerTest, ActionClientAllServicesPresentTest) {
+    create_retake_scheduler();
+
+    // Verify all 3 action services are visible on the graph
+    auto service_names_and_types = retake_scheduler_->get_service_names_and_types();
+    bool has_cancel = false, has_get_result = false, has_send_goal = false;
+
+    for (const auto& [ service_name, _ ] : service_names_and_types) {
+        if (service_name == "/retake_action/_action/cancel_goal") has_cancel = true;
+        if (service_name == "/retake_action/_action/get_result") has_get_result = true;
+        if (service_name == "/retake_action/_action/send_goal") has_send_goal = true;
+    }
+
+    EXPECT_TRUE(has_cancel) << "cancel_goal service should be available";
+    EXPECT_TRUE(has_get_result) << "get_result service should be available";
+    EXPECT_TRUE(has_send_goal) << "send_goal service should be available";
+}
+
+TEST_F(RetakeSchedulerTest, ConstructorWithNullDatabaseManager) {
+    // Explicitly construct with nullptr to exercise optional DB manager path
+    ASSERT_NO_THROW({
+        retake_scheduler_ = std::make_shared<RetakeScheduler>(nullptr);
+    });
+    ASSERT_NE(retake_scheduler_, nullptr);
+}
+

src/g2_2025_assign1_pkg/test/mocks/MockDatabaseManager.hpp

@@ -0,0 +1,73 @@
+#pragma once
+
+#include "database/DatabaseManager.hpp"
+
+namespace assignments::one {
+
+struct MockStoredResult {
+    StudentCourse sc;
+    int exam_count;
+    int final_grade;
+    bool is_retake;
+};
+
+class MockDatabaseManager : public DatabaseManager {
+public:
+    explicit MockDatabaseManager(
+        rclcpp::Logger logger = rclcpp::get_logger("fake_db")
+    )
+    : DatabaseManager(logger) {}
+
+    bool is_connected() const override {
+        return connection_status_;
+    }
+
+    void init_database() override {}
+
+    void set_connection_status(bool status) {
+        connection_status_ = status;
+    }
+
+    std::vector<StudentCourse> get_failed_course_results() {
+        return failed_students_;
+    }
+
+    bool store_final_course_result(
+        const StudentCourse& sc,
+        int exam_count,
+        int final_grade,
+        bool is_retake
+    ) {
+        stored_results.push_back({ sc, exam_count, final_grade, is_retake });
+        return true;
+    }
+
+    bool update_retake_status(const StudentCourse& sc) {
+        retake_status_updates.push_back(sc);
+        return true;
+    }
+
+    void clear_failed_students() {
+        failed_students_.clear();
+    }
+
+    void add_failed_student(const std::string& student_name, const std::string& course_name) {
+        StudentCourse sc;
+        sc.student_name = student_name;
+        sc.course_name = course_name;
+        failed_students_.push_back(sc);
+    }
+
+    void set_failed_students(const std::vector<StudentCourse>& failed_students) {
+        failed_students_ = failed_students;
+    }
+
+    std::vector<MockStoredResult> stored_results;
+    std::vector<StudentCourse> retake_status_updates;
+
+private:
+    std::vector<StudentCourse> failed_students_;
+    bool connection_status_ = true;
+};
+
+} // namespace assignments::one

src/g2_2025_assign1_pkg/test/mocks/MockRetakeActionServer.hpp

@@ -0,0 +1,57 @@
+#pragma once
+
+namespace assignments::one {
+
+class MockRetakeActionServer {
+public:
+    MockRetakeActionServer(std::shared_ptr<rclcpp::Node> node) : node_(node) {
+        action_server_ = rclcpp_action::create_server<g2_2025_assign1_interfaces_pkg::action::Retake>(
+            node_,
+            "retake_action",
+            std::bind(&MockRetakeActionServer::handle_goal, this, std::placeholders::_1, std::placeholders::_2),
+            std::bind(&MockRetakeActionServer::handle_cancel, this, std::placeholders::_1),
+            std::bind(&MockRetakeActionServer::handle_accepted, this, std::placeholders::_1)
+        );
+    }
+
+    rclcpp_action::GoalResponse handle_goal(
+        const rclcpp_action::GoalUUID & uuid,
+        std::shared_ptr<const g2_2025_assign1_interfaces_pkg::action::Retake::Goal> goal
+    ) {
+        (void)uuid;
+        received_goals_.push_back(*goal);
+        return goal_response_;
+    }
+
+    rclcpp_action::CancelResponse handle_cancel(
+        const std::shared_ptr<rclcpp_action::ServerGoalHandle<g2_2025_assign1_interfaces_pkg::action::Retake>> goal_handle
+    ) {
+        (void)goal_handle;
+        cancel_requests++;
+        return rclcpp_action::CancelResponse::ACCEPT;
+    }
+
+    void handle_accepted(const std::shared_ptr<rclcpp_action::ServerGoalHandle<g2_2025_assign1_interfaces_pkg::action::Retake>> goal_handle) {
+        accepted_goals++;
+
+        // Simulate immediate success
+        auto result = std::make_shared<g2_2025_assign1_interfaces_pkg::action::Retake::Result>();
+        result->result = 0.0;
+        goal_handle->succeed(result);
+    }
+
+    void set_goal_response(rclcpp_action::GoalResponse response) {
+        goal_response_ = response;
+    }
+
+    std::vector<g2_2025_assign1_interfaces_pkg::action::Retake::Goal> received_goals_;
+    int accepted_goals = 0;
+    int cancel_requests = 0;
+
+private:
+    std::shared_ptr<rclcpp::Node> node_;
+    rclcpp_action::Server<g2_2025_assign1_interfaces_pkg::action::Retake>::SharedPtr action_server_;
+    rclcpp_action::GoalResponse goal_response_ = rclcpp_action::GoalResponse::ACCEPT_AND_EXECUTE;
+};
+
+} // namespace assignments::one

src/g2_2025_assign1_pkg/test/test_integration_system.py

@@ -0,0 +1,194 @@
+import time
+import rclpy
+from rclpy.node import Node
+from rclpy.executors import SingleThreadedExecutor
+from g2_2025_interfaces.msg import Exam, Student
+from g2_2025_interfaces.srv import Exams
+
+
+class IntegrationTestNode(Node):
+    """Test node for integration testing of the grade calculator"""
+
+    def __init__(self):
+        super().__init__('integration_test_node')
+
+        self.received_exams = []
+        self.received_students = []
+
+        self.student_publisher = self.create_publisher(
+            Student,
+            'student_course_management',
+            10
+        )
+
+        self.exam_subscriber = self.create_subscription(
+            Exam,
+            'exam_results',
+            self.exam_callback,
+            10
+        )
+
+        self.grade_calculator_client = self.create_client(
+            Exams,
+            'grade_calculator_service'
+        )
+
+    def exam_callback(self, msg):
+        """Callback for received exam messages"""
+        self.get_logger().info(f'Received exam: {msg.student_name} - {msg.course_name} - {msg.result}')
+        self.received_exams.append(msg)
+
+    def publish_student_enrollment(self, student_name, course_name):
+        """Publish a student enrollment message"""
+        msg = Student()
+        msg.student_name = student_name
+        msg.course_name = course_name
+        msg.timestamp = self.get_clock().now().to_msg()
+
+        self.get_logger().info(f'Publishing student enrollment: {student_name} - {course_name}')
+        self.student_publisher.publish(msg)
+
+    def call_grade_calculator_service(self, student_name, grades):
+        """Call the grade calculator service"""
+        if not self.grade_calculator_client.wait_for_service(timeout_sec=5.0):
+            self.get_logger().warn('Grade calculator service not available')
+            return None
+
+        request = Exams.Request()
+        request.student_name = student_name
+        request.grades = grades
+
+        future = self.grade_calculator_client.call_async(request)
+        return future
+
+
+def test_message_publishing():
+    """Test basic message publishing and receiving"""
+    rclpy.init()
+
+    try:
+        node = IntegrationTestNode()
+        executor = SingleThreadedExecutor()
+        executor.add_node(node)
+
+        # Allow some time for setup
+        time.sleep(1.0)
+
+        # Test publishing student enrollment
+        node.publish_student_enrollment("TestStudent", "TestCourse")
+
+        # Spin for a short time to process messages
+        start_time = time.time()
+        while time.time() - start_time < 3.0:
+            executor.spin_once(timeout_sec=0.1)
+
+        # Test passes if no exceptions occurred
+        assert True, "Message publishing test completed"
+
+    finally:
+        node.destroy_node()
+        rclpy.shutdown()
+
+
+def test_grade_calculator_service():
+    """Test the grade calculator service"""
+    rclpy.init()
+
+    try:
+        node = IntegrationTestNode()
+        executor = SingleThreadedExecutor()
+        executor.add_node(node)
+
+        # Test grade calculation
+        future = node.call_grade_calculator_service("TestStudent", [80, 90, 70])
+
+        if future is not None:
+            # Spin until service response received or timeout
+            start_time = time.time()
+            while not future.done() and time.time() - start_time < 10.0:
+                executor.spin_once(timeout_sec=0.1)
+
+            if future.done():
+                result = future.result()
+                # Verify the result is reasonable
+                assert 10 <= result.final_grade <= 100, f"Grade {result.final_grade} is out of valid range"
+                assert result.final_grade == 80, f"Expected grade 80, got {result.final_grade}"
+            else:
+                # Service not available, test passes with warning
+                print("Warning: Grade calculator service not available during test")
+
+        assert True, "Grade calculator service test completed"
+
+    finally:
+        node.destroy_node()
+        rclpy.shutdown()
+
+
+def test_system_integration():
+    """Test integration between multiple components"""
+    rclpy.init()
+
+    try:
+        node = IntegrationTestNode()
+        executor = SingleThreadedExecutor()
+        executor.add_node(node)
+
+        # Clear any existing messages
+        node.received_exams.clear()
+
+        # Publish student enrollment
+        node.publish_student_enrollment("IntegrationStudent", "IntegrationCourse")
+
+        # Spin and wait for potential exam results
+        start_time = time.time()
+        while time.time() - start_time < 5.0:
+            executor.spin_once(timeout_sec=0.1)
+
+        assert True, "System integration test completed"
+
+        for exam in node.received_exams:
+            assert 10 <= exam.result <= 100, f"Exam grade {exam.result} is out of valid range"
+            assert len(exam.student_name) > 0, "Student name should not be empty"
+            assert len(exam.course_name) > 0, "Course name should not be empty"
+
+    finally:
+        node.destroy_node()
+        rclpy.shutdown()
+
+
+def test_multiple_enrollments():
+    """Test handling multiple student enrollments"""
+    rclpy.init()
+
+    try:
+        node = IntegrationTestNode()
+        executor = SingleThreadedExecutor()
+        executor.add_node(node)
+
+        test_students = [
+            ("Tilmann", "Differentieren"),
+            ("Vincent", "Integreren"),
+            ("Wessel", "Kompjuteren")
+        ]
+
+        for student, course in test_students:
+            node.publish_student_enrollment(student, course)
+            time.sleep(0.1)
+
+        # Spin to process messages
+        start_time = time.time()
+        while time.time() - start_time < 3.0:
+            executor.spin_once(timeout_sec=0.1)
+
+        assert True, "Multiple enrollments test completed"
+
+    finally:
+        node.destroy_node()
+        rclpy.shutdown()
+
+
+if __name__ == '__main__':
+    test_message_publishing()
+    test_grade_calculator_service()
+    test_system_integration()
+    test_multiple_enrollments()

src/g2_2025_imu_reader_pkg/CMakeLists.txt

@@ -1,166 +0,0 @@
-cmake_minimum_required(VERSION 3.8)
-project(g2_2025_imu_reader_pkg)
-
-if(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-  add_compile_options(-Wall -Wextra -Wpedantic)
-endif()
-
-# external packages
-include(FetchContent)
-
-FetchContent_Declare(
-    tomlplusplus
-    GIT_REPOSITORY https://github.com/marzer/tomlplusplus.git
-    GIT_TAG v3.4.0
-)
-
-FetchContent_MakeAvailable(tomlplusplus)
-
-FetchContent_Declare(
-    nlohmann_json
-    GIT_REPOSITORY https://github.com/nlohmann/json.git
-    GIT_TAG v3.12.0
-)
-
-FetchContent_MakeAvailable(nlohmann_json)
-
-# find dependencies
-find_package(ament_cmake REQUIRED)
-find_package(rclcpp REQUIRED)
-find_package(rclcpp_action REQUIRED)
-find_package(std_msgs REQUIRED)
-find_package(sensor_msgs REQUIRED)
-find_package(rclcpp_lifecycle REQUIRED)
-
-add_executable(g2_2025_imu_database_writer_node
-    src/g2_2025_imu_database_writer_node/Main.cpp
-    src/database/DatabaseManager.cpp
-    src/config/ConfigManager.cpp
-    src/g2_2025_imu_database_writer_node/nodes/IMUDatabaseWriter.cpp
-)
-
-target_include_directories(g2_2025_imu_database_writer_node PRIVATE
-    ${CMAKE_CURRENT_SOURCE_DIR}/src
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/g2_2025_imu_database_writer_node
-)
-ament_target_dependencies(g2_2025_imu_database_writer_node rclcpp sensor_msgs)
-target_link_libraries(g2_2025_imu_database_writer_node pqxx pq tomlplusplus::tomlplusplus)
-
-add_executable(g2_2025_lifecycle_node
-    src/g2_2025_lifecycle_node/Main.cpp
-    src/g2_2025_lifecycle_node/nodes/HardwareInterface.cpp
-    src/g2_2025_lifecycle_node/nodes/LifecycleManager.cpp
-    lib/serialib.cpp
-)
-
-target_include_directories(g2_2025_lifecycle_node PRIVATE
-    ${CMAKE_CURRENT_SOURCE_DIR}/src
-    ${CMAKE_CURRENT_SOURCE_DIR}/lib
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/g2_2025_lifecycle_node
-)
-ament_target_dependencies(g2_2025_lifecycle_node rclcpp rclcpp_lifecycle std_msgs sensor_msgs)
-
-target_link_libraries(g2_2025_lifecycle_node
-  paho-mqttpp3
-  paho-mqtt3c
-  nlohmann_json::nlohmann_json
-)
-
-install(
-    TARGETS
-        g2_2025_imu_database_writer_node
-        g2_2025_lifecycle_node
-    DESTINATION lib/${PROJECT_NAME}
-)
-
-install(
-    DIRECTORY launch
-    DESTINATION share/${PROJECT_NAME}/
-)
-set_target_properties(g2_2025_lifecycle_node PROPERTIES INSTALL_RPATH "/usr/local/lib")
-
-if(BUILD_TESTING)
-  find_package(ament_cmake_gtest REQUIRED)
-
-  # Add gtest for ConfigManager
-  ament_add_gtest(${PROJECT_NAME}_test_config_manager
-    test/ConfigManager.test.cpp
-    src/config/ConfigManager.cpp
-  )
-  target_include_directories(${PROJECT_NAME}_test_config_manager PRIVATE
-    ${CMAKE_CURRENT_SOURCE_DIR}/src
-  )
-  ament_target_dependencies(${PROJECT_NAME}_test_config_manager
-    rclcpp
-  )
-  target_link_libraries(${PROJECT_NAME}_test_config_manager
-    tomlplusplus::tomlplusplus
-  )
-
-  # Add gtest for IMUDatabaseWriter node
-  ament_add_gtest(${PROJECT_NAME}_test_imu_database_writer
-    test/IMUDatabaseWriter.test.cpp
-    src/g2_2025_imu_database_writer_node/nodes/IMUDatabaseWriter.cpp
-    src/database/DatabaseManager.cpp
-    src/config/ConfigManager.cpp
-  )
-  target_include_directories(${PROJECT_NAME}_test_imu_database_writer PRIVATE
-    ${CMAKE_CURRENT_SOURCE_DIR}/src
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/g2_2025_imu_database_writer_node
-  )
-  ament_target_dependencies(${PROJECT_NAME}_test_imu_database_writer
-    rclcpp
-    sensor_msgs
-  )
-  target_link_libraries(${PROJECT_NAME}_test_imu_database_writer
-    pqxx pq tomlplusplus::tomlplusplus
-  )
-
-  # Add gtest for DatabaseManager
-  ament_add_gtest(${PROJECT_NAME}_test_database_manager
-    test/DatabaseManager.test.cpp
-    src/database/DatabaseManager.cpp
-    src/config/ConfigManager.cpp
-  )
-  target_include_directories(${PROJECT_NAME}_test_database_manager PRIVATE
-    ${CMAKE_CURRENT_SOURCE_DIR}/src
-  )
-  ament_target_dependencies(${PROJECT_NAME}_test_database_manager
-    rclcpp
-  )
-  target_link_libraries(${PROJECT_NAME}_test_database_manager
-    pqxx pq tomlplusplus::tomlplusplus
-  )
-
-  ament_add_gtest(${PROJECT_NAME}_test_lifecycle_manager
-    test/LifecycleManager.test.cpp
-    src/g2_2025_lifecycle_node/nodes/LifecycleManager.cpp
-    src/g2_2025_lifecycle_node/nodes/HardwareInterface.cpp
-    lib/serialib.cpp
-  )
-  target_include_directories(${PROJECT_NAME}_test_lifecycle_manager PRIVATE
-    ${CMAKE_CURRENT_SOURCE_DIR}/src
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/g2_2025_lifecycle_node
-    ${CMAKE_CURRENT_SOURCE_DIR}/lib
-  )
-  ament_target_dependencies(${PROJECT_NAME}_test_lifecycle_manager
-    rclcpp
-    rclcpp_lifecycle
-    std_msgs
-    sensor_msgs
-  )
-  target_link_libraries(${PROJECT_NAME}_test_lifecycle_manager
-    paho-mqttpp3
-    paho-mqtt3c
-    nlohmann_json::nlohmann_json
-  )
-  set_target_properties(${PROJECT_NAME}_test_lifecycle_manager PROPERTIES INSTALL_RPATH "/usr/local/lib")
-
-  # Add Python integration tests
-  #   find_package(ament_cmake_pytest REQUIRED)
-  #   ament_add_pytest_test(${PROJECT_NAME}_integration_test test/test_integration_system.py
-  #     TIMEOUT 60
-  #   )
-endif()
-
-ament_package()

src/g2_2025_imu_reader_pkg/launch/mqtt.launch.xml

@@ -1,6 +0,0 @@
-<launch>
-    <node pkg="g2_2025_imu_reader_pkg" exec="g2_2025_imu_database_writer_node"/>
-    <node pkg="g2_2025_imu_reader_pkg" exec="g2_2025_lifecycle_node">
-        <param name="comm_t" value="mqtt"/>
-    </node>
-</launch>

src/g2_2025_imu_reader_pkg/launch/serial.launch.xml

@@ -1,8 +0,0 @@
-<launch>
-    <node pkg="g2_2025_imu_reader_pkg" exec="g2_2025_imu_database_writer_node"/>
-    <node pkg="g2_2025_imu_reader_pkg" exec="g2_2025_lifecycle_node">
-        <param name="device_path" value="/dev/ttyUSB0"/>
-        <param name="baudrate" value="115200"/>
-        <param name="comm_t" value="serial"/>
-    </node>
-</launch>

src/g2_2025_imu_reader_pkg/lib/serialib.h

@@ -1,270 +0,0 @@
-/*!
-\file    serialib.h
-\brief   Header file of the class serialib. This class is used for communication over a serial device.
-\author  Philippe Lucidarme (University of Angers)
-\version 2.0
-\date    december the 27th of 2019
-This Serial library is used to communicate through serial port.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
-INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
-PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE X CONSORTIUM BE LIABLE FOR ANY CLAIM,
-DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-This is a licence-free software, it can be used by anyone who try to build a better world.
-*/
-
-
-#ifndef SERIALIB_H
-#define SERIALIB_H
-
-#if defined(__CYGWIN__)
-    // This is Cygwin special case
-    #include <sys/time.h>
-#endif
-
-// Include for windows
-#if defined (_WIN32) || defined (_WIN64)
-#if defined(__GNUC__)
-    // This is MinGW special case
-    #include <sys/time.h>
-#else
-    // sys/time.h does not exist on "actual" Windows
-    #define NO_POSIX_TIME
-#endif
-    // Accessing to the serial port under Windows
-    #include <windows.h>
-#endif
-
-// Include for Linux
-#if defined (__linux__) || defined(__APPLE__)
-    #include <stdlib.h>
-    #include <sys/types.h>
-    #include <sys/shm.h>
-    #include <termios.h>
-    #include <string.h>
-    #include <iostream>
-    #include <sys/time.h>
-    // File control definitions
-    #include <fcntl.h>
-    #include <unistd.h>
-    #include <sys/ioctl.h>
-#endif
-
-/*! To avoid unused parameters */
-#define UNUSED(x) (void)(x)
-
-/**
- * number of serial data bits
- */
-enum SerialDataBits {
-    SERIAL_DATABITS_5, /**< 5 databits */
-    SERIAL_DATABITS_6, /**< 6 databits */
-    SERIAL_DATABITS_7, /**< 7 databits */
-    SERIAL_DATABITS_8,  /**< 8 databits */
-    SERIAL_DATABITS_16,  /**< 16 databits */
-};
-
-/**
- * number of serial stop bits
- */
-enum SerialStopBits {
-    SERIAL_STOPBITS_1, /**< 1 stop bit */
-    SERIAL_STOPBITS_1_5, /**< 1.5 stop bits */
-    SERIAL_STOPBITS_2, /**< 2 stop bits */
-};
-
-/**
- * type of serial parity bits
- */
-enum SerialParity {
-    SERIAL_PARITY_NONE, /**< no parity bit */
-    SERIAL_PARITY_EVEN, /**< even parity bit */
-    SERIAL_PARITY_ODD, /**< odd parity bit */
-    SERIAL_PARITY_MARK, /**< mark parity */
-    SERIAL_PARITY_SPACE /**< space bit */
-};
-
-/*!  \class     serialib
-     \brief     This class is used for communication over a serial device.
-*/
-class serialib
-{
-public:
-
-    //_____________________________________
-    // ::: Constructors and destructors :::
-
-
-
-    // Constructor of the class
-    serialib    ();
-
-    // Destructor
-    ~serialib   ();
-
-
-
-    //_________________________________________
-    // ::: Configuration and initialization :::
-
-
-    // Open a device
-    char openDevice(const char *Device, const unsigned int Bauds,
-                    SerialDataBits Databits = SERIAL_DATABITS_8,
-                    SerialParity Parity = SERIAL_PARITY_NONE,
-                    SerialStopBits Stopbits = SERIAL_STOPBITS_1);
-
-    // Check device opening state
-    bool isDeviceOpen();
-
-    // Close the current device
-    void    closeDevice();
-
-
-
-
-    //___________________________________________
-    // ::: Read/Write operation on characters :::
-
-
-    // Write a char
-    int     writeChar   (char);
-
-    // Read a char (with timeout)
-    int     readChar    (char *pByte,const unsigned int timeOut_ms=0);
-
-
-
-
-    //________________________________________
-    // ::: Read/Write operation on strings :::
-
-
-    // Write a string
-    int     writeString (const char *String);
-
-    // Read a string (with timeout)
-    int     readString  (   char *receivedString,
-                            char finalChar,
-                            unsigned int maxNbBytes,
-                            const unsigned int timeOut_ms=0);
-
-
-
-    // _____________________________________
-    // ::: Read/Write operation on bytes :::
-
-
-    // Write an array of bytes
-    int     writeBytes(const void *Buffer, const unsigned int NbBytes, unsigned int *NbBytesWritten);
-    int     writeBytes  (const void *Buffer, const unsigned int NbBytes);
-
-    // Read an array of byte (with timeout)
-    int     readBytes   (void *buffer,unsigned int maxNbBytes,const unsigned int timeOut_ms=0, unsigned int sleepDuration_us=100);
-
-
-
-
-    // _________________________
-    // ::: Special operation :::
-
-
-    // Empty the received buffer
-    char    flushReceiver();
-
-    // Return the number of bytes in the received buffer
-    int     available();
-
-
-
-
-    // _________________________
-    // ::: Access to IO bits :::
-
-
-    // Set CTR status (Data Terminal Ready, pin 4)
-    bool    DTR(bool status);
-    bool    setDTR();
-    bool    clearDTR();
-
-    // Set RTS status (Request To Send, pin 7)
-    bool    RTS(bool status);
-    bool    setRTS();
-    bool    clearRTS();
-
-    // Get RI status (Ring Indicator, pin 9)
-    bool    isRI();
-
-    // Get DCD status (Data Carrier Detect, pin 1)
-    bool    isDCD();
-
-    // Get CTS status (Clear To Send, pin 8)
-    bool    isCTS();
-
-    // Get DSR status (Data Set Ready, pin 9)
-    bool    isDSR();
-
-    // Get RTS status (Request To Send, pin 7)
-    bool    isRTS();
-
-    // Get CTR status (Data Terminal Ready, pin 4)
-    bool    isDTR();
-
-
-private:
-    // Read a string (no timeout)
-    int             readStringNoTimeOut  (char *String,char FinalChar,unsigned int MaxNbBytes);
-
-    // Current DTR and RTS state (can't be read on WIndows)
-    bool            currentStateRTS;
-    bool            currentStateDTR;
-
-
-
-
-
-#if defined (_WIN32) || defined( _WIN64)
-    // Handle on serial device
-    HANDLE          hSerial;
-    // For setting serial port timeouts
-    COMMTIMEOUTS    timeouts;
-#endif
-#if defined (__linux__) || defined(__APPLE__)
-    int             fd;
-#endif
-
-};
-
-
-
-/*!  \class     timeOut
-     \brief     This class can manage a timer which is used as a timeout.
-   */
-// Class timeOut
-class timeOut
-{
-public:
-
-    // Constructor
-    timeOut();
-
-    // Init the timer
-    void                initTimer();
-
-    // Return the elapsed time since initialization
-    unsigned long int   elapsedTime_ms();
-
-private:
-#if defined (NO_POSIX_TIME)
-    // Used to store the previous time (for computing timeout)
-    LONGLONG       counterFrequency;
-    LONGLONG       previousTime;
-#else
-    // Used to store the previous time (for computing timeout)
-    struct timeval      previousTime;
-#endif
-};
-
-#endif // serialib_H

src/g2_2025_imu_reader_pkg/src/config/DatabaseConfig.hpp

@@ -1,46 +0,0 @@
-/* DatabaseConfig.hpp
- * Database configuration structure
- *
- * Reviewed by: <x>
- * Changelog:
- * [23-09-2025] Wessel T: Create initial configuration structure
- */
-#pragma once
-
-#include <string>
-
-namespace assignments::two {
-
-struct DatabaseConfig {
-    std::string host;
-    int port;
-    std::string dbname;
-    std::string user;
-    std::string password;
-    int timeout;
-    bool ssl;
-
-    // Pool settings
-    int min_connections;
-    int max_connections;
-
-    std::string to_connection_string() const {
-        std::string conn_str =
-            "host=" + host +
-            " port=" + std::to_string(port) +
-            " dbname=" + dbname +
-            " user=" + user +
-            " password=" + password +
-            " connect_timeout=" + std::to_string(timeout);
-
-        if (ssl) {
-            conn_str += " sslmode=require";
-        } else {
-            conn_str += " sslmode=disable";
-        }
-
-        return conn_str;
-    }
-};
-
-} // namespace assignments::two

src/g2_2025_imu_reader_pkg/src/database/DatabaseManager.cpp

@@ -1,116 +0,0 @@
-#include "DatabaseManager.hpp"
-
-#include <pqxx/pqxx>
-#include "rclcpp/rclcpp.hpp"
-
-#include "SQLQueries.hpp"
-#include "config/ConfigManager.hpp"
-
-namespace assignments::two {
-
-DatabaseManager::DatabaseManager(rclcpp::Logger logger) : logger_(logger) {
-    config_manager_ = std::make_unique<ConfigManager>(logger_);
-    init_database();
-}
-
-bool DatabaseManager::is_connected() const {
-    return conn_ && conn_->is_open();
-}
-
-bool DatabaseManager::connect(const std::string& connection_string) {
-    try {
-        RCLCPP_INFO(logger_, "[DBS] connecting to PostgreSQL database...");
-
-        conn_ = std::make_unique<pqxx::connection>(connection_string);
-
-        if (conn_->is_open()) {
-            RCLCPP_INFO(logger_, "[DBS] '%s': successfully connected to database", conn_->dbname());
-            return true;
-        } else {
-            RCLCPP_ERROR(logger_, "[DBS] failed to open database connection");
-            return false;
-        }
-
-    } catch (const pqxx::sql_error &e) {
-        RCLCPP_ERROR(logger_, "[DBS] sql error: %s", e.what());
-        return false;
-    } catch (const std::exception &e) {
-        RCLCPP_ERROR(logger_, "[DBS] connection error: %s", e.what());
-        return false;
-    }
-}
-
-void DatabaseManager::init_database() {
-    if (!config_manager_ || !config_manager_->is_loaded()) {
-        RCLCPP_ERROR(logger_, "[DBS] configuration not loaded, cannot initialize database");
-        return;
-    }
-
-    auto db_config = config_manager_->get_database_config();
-    if (!db_config.has_value()) {
-        RCLCPP_ERROR(logger_, "[DBS] failed to get database configuration");
-        return;
-    }
-
-    std::string connection_string = db_config->to_connection_string();
-
-    if (connect(connection_string)) {
-        create_tables();
-    }
-}
-
-void DatabaseManager::create_tables() {
-    if (!conn_ || !conn_->is_open()) return;
-
-    try {
-        pqxx::work txn(*conn_);
-
-        txn.exec(SQL_CREATE_IMU_DATA_TABLE);
-
-        txn.commit();
-
-        RCLCPP_INFO(logger_, "[DBS] database tables ready");
-
-    } catch (const pqxx::sql_error &e) {
-        RCLCPP_ERROR(logger_, "[DBS] CREATE TABLE failed: %s", e.what());
-    } catch (const std::exception &e) {
-        RCLCPP_ERROR(logger_, "[DBS] database error: %s", e.what());
-    }
-}
-
-bool DatabaseManager::store_imu_data(
-    double linear_accel_x, double linear_accel_y, double linear_accel_z,
-    double angular_vel_x, double angular_vel_y, double angular_vel_z
-) {
-    if (!is_connected()) {
-        RCLCPP_WARN(logger_, "[DBS] not connected to database");
-        return false;
-    }
-
-    try {
-        pqxx::work txn(*conn_);
-
-        txn.exec_params(SQL_INSERT_IMU_DATA,
-            linear_accel_x, linear_accel_y, linear_accel_z,
-            angular_vel_x, angular_vel_y, angular_vel_z
-        );
-
-        txn.commit();
-
-        RCLCPP_DEBUG(logger_, "[DBS] stored IMU data: accel=[%.3f,%.3f,%.3f], angular=[%.3f,%.3f,%.3f]",
-            linear_accel_x, linear_accel_y, linear_accel_z,
-            angular_vel_x, angular_vel_y, angular_vel_z
-        );
-
-        return true;
-
-    } catch (const pqxx::sql_error &e) {
-        RCLCPP_ERROR(logger_, "[DBS] failed to store IMU data: %s", e.what());
-        return false;
-    } catch (const std::exception &e) {
-        RCLCPP_ERROR(logger_, "[DBS] database error: %s", e.what());
-        return false;
-    }
-}
-
-} // namespace assignments::two

src/g2_2025_imu_reader_pkg/src/database/DatabaseManager.hpp

@@ -1,46 +0,0 @@
-/* DatabaseManager.hpp
- * Database manager for the IMU data collection system
- *
- * Reviewed by: <x>
- * Changelog:
- * [23-09-2025] Wessel T: Created database manager class for all DB operations
- * [14-10-2025] Wessel T: Updated for IMU data storage functionality
- */
-#pragma once
-
-#include <memory>
-#include <vector>
-#include <string>
-#include <pqxx/pqxx>
-#include "rclcpp/rclcpp.hpp"
-
-#include "config/ConfigManager.hpp"
-
-namespace assignments::two {
-
-class DatabaseManager {
-public:
-    explicit DatabaseManager(rclcpp::Logger logger);
-    ~DatabaseManager() = default;
-
-    bool connect(const std::string& connection_string);
-    virtual bool is_connected() const;
-
-    // Table operations
-    virtual void init_database();
-    void create_tables();
-
-    // IMU Data operations
-    virtual bool store_imu_data(
-        double linear_accel_x, double linear_accel_y, double linear_accel_z,
-        double angular_vel_x, double angular_vel_y, double angular_vel_z
-    );
-
-private:
-    rclcpp::Logger logger_;
-
-    std::unique_ptr<pqxx::connection> conn_;
-    std::unique_ptr<ConfigManager> config_manager_;
-};
-
-} // namespace assignments::two

src/g2_2025_imu_reader_pkg/src/database/SQLQueries.hpp

@@ -1,29 +0,0 @@
-/* SQLQueries.hpp
- * SQL query definitions for the IMU data collection system
- *
- * Reviewed by: <x>
- * Changelog:
- * [23-09-2025] Wessel T: Created initial database state
- * [14-10-2025] Wessel T: Updated for IMU data storage
- */
-#pragma once
-
-static const std::string SQL_CREATE_IMU_DATA_TABLE = R"(
-    CREATE TABLE IF NOT EXISTS imu_data (
-        id SERIAL PRIMARY KEY,
-        timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-        linear_accel_x REAL NOT NULL,
-        linear_accel_y REAL NOT NULL,
-        linear_accel_z REAL NOT NULL,
-        angular_vel_x REAL NOT NULL,
-        angular_vel_y REAL NOT NULL,
-        angular_vel_z REAL NOT NULL
-    );
-)";
-
-static const std::string SQL_INSERT_IMU_DATA = R"(
-    INSERT INTO imu_data (
-        linear_accel_x, linear_accel_y, linear_accel_z,
-        angular_vel_x, angular_vel_y, angular_vel_z
-    ) VALUES ($1, $2, $3, $4, $5, $6);
-)";

src/g2_2025_imu_reader_pkg/src/g2_2025_imu_database_writer_node/nodes/IMUDatabaseWriter.cpp

@@ -1,43 +0,0 @@
-#include "IMUDatabaseWriter.hpp"
-
-namespace assignments::two::imu_database_writer {
-
-IMUDatabaseWriter::IMUDatabaseWriter(std::unique_ptr<DatabaseManager> db_manager)
-    : Node("g2_2025_imu_database_writer_node")
-{
-    // allow injection of mock database manager for tests
-    if (db_manager) {
-        db_manager_ = std::move(db_manager);
-    } else {
-        db_manager_ = std::make_unique<DatabaseManager>(this->get_logger());
-    }
-
-    // Create subscriber for IMU data
-    imu_subscriber_ = this->create_subscription<sensor_msgs::msg::Imu>(
-        "imu_data", 10,
-        std::bind(
-            &IMUDatabaseWriter::imu_data_callback,
-            this,
-            std::placeholders::_1
-        )
-    );
-
-    RCLCPP_INFO(this->get_logger(),
-        "imu_database_writer started, ready to receive IMU data"
-    );
-}
-
-void IMUDatabaseWriter::imu_data_callback(const sensor_msgs::msg::Imu::SharedPtr msg) {
-    RCLCPP_DEBUG(this->get_logger(),
-        "Received: linear_accel=[%.2f, %.2f, %.2f], angular_vel=[%.2f, %.2f, %.2f]",
-        msg->linear_acceleration.x, msg->linear_acceleration.y, msg->linear_acceleration.z,
-        msg->angular_velocity.x, msg->angular_velocity.y, msg->angular_velocity.z
-    );
-
-    db_manager_->store_imu_data(
-        msg->linear_acceleration.x, msg->linear_acceleration.y, msg->linear_acceleration.z,
-        msg->angular_velocity.x, msg->angular_velocity.y, msg->angular_velocity.z
-    );
-}
-
-} // namespace assignments::two::imu_database_writer