CT087-3-3-RTS Realtime Systems L7 Assignment Brief | APU

CT087-3-3-RTS Assignment Scenario

Precision Control in an Automated Manufacturing Line: Rust-Based Sensor-Actuator

 In  a modern automated manufacturing plant, robotic arms play a crucial role in  assembling,  welding, and packaging products with extreme precision. These robotic systems rely on real-time sensor feedback to adjust their movements dynamically—whether it’s applying the right amount of pressure when gripping an object, compensating for vibrations, or realigning components on a fast-moving conveyor belt. Even a slight delay in response can lead to misalignment, defective products, or costly downtime.Your task is to develop a real-time sensor-actuator system similar to those used in robotic automation. One part of the system will continuously monitor sensor data from the robotic workspace (such as force, position, or temperature), while the other will control the robotic arm’s movements, ensuring smooth, precise, and timely adjustments. Everything must happen within strict real-time constraints, ensuring the system responds predictably and efÏciently.

This is a grouped-based assignment (assessed individually) where each student is responsible for one half of the system:Student A will develop the sensor data acquisition and processing module, monitoring environmental factors and potential anomalies affecting the robotic arm’s operation.Student   B   will   build   the   actuator  control  system,   dynamically   adjusting  the   robotic   arm’s   movement   based  on   thein coming sensor data to maintain precision and efÏciency.

The   success   of   your   system  depends   on   how   well   these   two   components   communicate   and   respond   to   real-time constraints, mirroring the challenges faced in industrial robotics, autonomous systems, and high-speed manufacturing.

Student A: The Sensor Data Specialist Your job is to simulate a real-time sensor and process its data efÏciently. 

You'll need to:

1. Generate Sensor Data:

• Simulate real-world force, position, or environmental sensors that provide feedback to the robotic arm.
• Ensure data is generated at fixed intervals (e.g., every 5ms) without excessive jitter.
• Use Rust’s real-time async features or real-time threads to maintain precision.

2. Process Data:

• Apply basic filtering techniques (such as a moving average) to remove noise.
• Implement anomaly detection, either with a threshold-based approach or a simple machine learning model, to detect irregular sensor readings (e.g., unexpected resistance on the robotic arm).
• Ensure that processing completes within 2ms per cycle to allow timely response.

3. Transmit Data in Real Time:

• Send   processed   sensor   data   to   Student   B’s   actuator   control   module   using   an   efÏcient   inter-process communication (IPC) method (e.g., message queues, shared memory, or network sockets).
• Meet strict deadlines—data must be transmitted within 1ms after processing.

4. Benchmark Performance:

• Measure execution times for each stage (sensor data generation, processing, and transmission).
• Monitor jitter, latency, and throughput under different workloads.
• Compare system performance under normal vs. high-load conditions (e.g., increased sensor data frequency).
• Provide insights into possible optimizations based on performance analysis.

Student B: The Actuator Commander On the other end of the system, your job is to control the robotic arm’s movements based on real-time sensor data.

1. Receive Sensor Data:

• Implement a Rust module that receives processed sensor data from Student A.
• Handle communication efÏciently to minimize latency.
• Ensure that data reception occurs within 1ms of transmission from Student A.

2. Control the Robotic Arm with Predictive Algorithms:

• Implement   a   virtual   robotic   arm   that   performs   actions   based   on   sensor   input   (e.g.,   adjusting   grip   force,repositioning to correct misalignment).
• Integrate   a   Predictive  Control   Algorithm  (such   as   a   PID  controller)  to   dynamically   adjust   the   robotic   arm’sresponse based on trends in sensor data.
• Prioritize   critical   actuator   tasks   using   real-time   scheduling   techniques   to   ensure   the   most   time-sensitivemovements are executed first.
• Ensure actuator response is executed within 2ms of receiving sensor data.

3. Manage Multiple Actuators:

• Extend   the   system   to   control   multiple  actuators   on   the   robotic   arm   (e.g.,   grippers,   motors,   or   stabilizers) simultaneously.
• Implement real-time resource allocation to manage these actuators efÏciently, ensuring each responds within itsassigned deadline (1-2ms depending on priority).

4. Close the Feedback Loop:

• Send real-time feedback to Student A (e.g., acknowledgment, control status, or detected resistance).
• Allow Student A’s module to dynamically adjust  sensor processing based on this feedback (e.g., recalibratingthreshold values or refining anomaly detection).
• Ensure feedback transmission completes within 1ms of actuation execution.

5. Bench marking & Optimization:

• Measure actuation response times and latency from data reception to actuation.
• Analyze task scheduling efÏciency under different loads.
• Log missed deadlines, if any, and analyze the causes.
• Evaluate system scalability and robustness under varying real-time constraints.Evaluation CriteriaYour project will be assessed based on the following:
• Correctness – Does each component function as intended?
• Real-Time Performance – Are response times predictable and within deadlines?
• EfÏciency – Are Rust’s strengths (such as memory safety and concurrency) used effectively?
• Interoperability – How seamlessly do the two components exchange data?
• Scalability – Can the system handle multiple actuators and dynamic conditions?
• Code Quality & Documentation – Is the Rust code well-structured and documented?
• Performance Bench marking – How thorough is your performance analysis?

Documentation Structure

3000 words You are required to write up your research in the form of an academic research article which will discuss your solution to your problem in terms of design and concepts used, as well as provide benchmark/performance results for both your simulation and that of your classmate.

The structure of the research paper is as follows (details of each section are on the next page)

• Abstract
• Introduction including problem statement and aim of the paper
• Literature review / related work (Research on Rust Concepts)
• Design  (How you designed your simulation)
• Results and discussion (Code curation and benchmarking results)
• Conclusion
• References