Demo page details

Page source code: sys_3_sys_arch.rst

  1{% set page="sys_3_sys_arch.rst" %}
  2{% include "demo_page_header.rst" with context %}
  3
  4.. _SYS3_Architecture_Design:
  5
  6===========================
  7SYS.3 Architecture Design
  8===========================
  9
 10.. arch:: Lane Detection Module
 11   :id: ARCH_001
 12   :status: in progress
 13   :links: REQ_001, REQ_002
 14   :author: ALFRED
 15
 16   Design the architecture for the Lane Detection Module, including components for camera input processing, lane identification, and integration with steering control.
 17
 18   .. uml::
 19
 20      @startuml
 21      node "Vehicle" {
 22          component LaneDetection  {
 23              agent detectLaneMarkings
 24              agent applySteeringCorrection
 25          }
 26          component CameraInput {
 27              agent captureData
 28          }
 29          component SteeringControl {
 30              agent correctSteering
 31          }
 32      }
 33      CameraInput --> LaneDetection
 34      LaneDetection --> SteeringControl
 35      @enduml
 36
 37.. arch:: Adaptive Cruise Control System
 38   :id: ARCH_002
 39   :status: closed
 40   :links: REQ_003, REQ_004
 41   :author: ALFRED
 42
 43   Define the architecture for the Adaptive Cruise Control System, with subsystems for distance measurement, speed adjustment, and communication with the vehicle's control systems.
 44
 45   .. uml::
 46
 47      @startuml
 48      node "Vehicle" {
 49          component AdaptiveCruiseControl {
 50              agent measureDistance
 51              agent adjustSpeed
 52          }
 53          component RadarSensor {
 54              agent measureDistance
 55          }
 56          component SpeedController {
 57              agent adjustSpeed
 58          }
 59          component CommunicationModule {
 60              agent sendReceiveData
 61          }
 62      }
 63      RadarSensor --> AdaptiveCruiseControl
 64      AdaptiveCruiseControl --> SpeedController
 65      SpeedController --> CommunicationModule
 66      @enduml
 67
 68.. arch:: Collision Avoidance System
 69   :id: ARCH_003
 70   :status: open
 71   :links: REQ_005, REQ_006
 72   :author: ALFRED
 73
 74   Develop the architecture for the Collision Avoidance System, focusing on modules for collision detection, predictive analytics, and autonomous braking.
 75
 76   .. uml::
 77
 78      @startuml
 79      node "Vehicle" {
 80          component CollisionAvoidance {
 81              agent detectCollisionRisk
 82              agent applyEmergencyBraking
 83          }
 84          component CollisionDetector {
 85              agent detectCollision
 86          }
 87          component RiskAnalyzer {
 88              agent analyzeRisk
 89          }
 90          component BrakeController {
 91              agent applyBrakes
 92          }
 93      }
 94      CollisionDetector --> RiskAnalyzer
 95      RiskAnalyzer --> BrakeController
 96      BrakeController --> CollisionAvoidance
 97      @enduml
 98
 99.. arch:: Pedestrian Safety Framework
100   :id: ARCH_004
101   :status: open
102   :links: REQ_007, REQ_008, REQ_009
103   :author: ALFRED
104
105   Create the architecture for the Pedestrian Safety Framework, integrating pedestrian detection, alert mechanisms, and emergency braking functionalities.
106
107   .. uml::
108
109      @startuml
110      node "Vehicle" {
111          component PedestrianSafety {
112              agent detectPedestrians
113              agent alertDriver
114              agent applyEmergencyBrakes
115          }
116          component PedestrianDetector {
117              agent detectPedestrians
118          }
119          component AlertSystem {
120              agent triggerAlert
121          }
122          component EmergencyBrakeController {
123              agent applyEmergencyBrakes
124          }
125      }
126      PedestrianDetector --> AlertSystem
127      AlertSystem --> EmergencyBrakeController
128      EmergencyBrakeController --> PedestrianSafety
129      @enduml
130
131.. arch:: Alert System Framework
132   :id: ARCH_005
133   :status: open
134   :links: REQ_008
135   :author: ALFRED
136
137   Design the system-level architecture for the Alert System Framework, integrating multiple types of driver alerts including audio, visual, and haptic feedback mechanisms.
138
139   .. uml::
140
141      @startuml
142      node "Vehicle" {
143          component AlertSystem {
144              agent manageAlerts
145              agent prioritizeAlerts
146          }
147          component AudioAlerts {
148              agent generateAudioAlert
149          }
150          component VisualAlerts {
151              agent displayVisualAlert
152          }
153          component HapticAlerts {
154              agent provideHapticFeedback
155          }
156          component SensorInputs {
157              agent receiveAlertTriggers
158          }
159      }
160      SensorInputs --> AlertSystem
161      AlertSystem --> AudioAlerts
162      AlertSystem --> VisualAlerts
163      AlertSystem --> HapticAlerts
164      @enduml
165
166.. arch:: Emergency Braking System
167   :id: ARCH_006
168   :status: open
169   :links: REQ_009
170   :author: ALFRED
171
172   Create the system architecture for the Emergency Braking System, focusing on rapid response, optimal braking force calculation, and integration with pedestrian detection systems.
173
174   .. uml::
175
176      @startuml
177      node "Vehicle" {
178          component EmergencyBrakingSystem {
179              agent calculateBrakingForce
180              agent initiateEmergencyBraking
181          }
182          component BrakeActuator {
183              agent applyBrakes
184          }
185          component ForceCalculator {
186              agent optimizeBrakingForce
187          }
188          component ResponseTimer {
189              agent measureResponseTime
190          }
191          component PedestrianDetection {
192              agent detectPedestrianThreat
193          }
194      }
195      PedestrianDetection --> EmergencyBrakingSystem
196      EmergencyBrakingSystem --> ForceCalculator
197      ForceCalculator --> BrakeActuator
198      EmergencyBrakingSystem --> ResponseTimer
199      @enduml
200
201.. arch:: Traffic Sign Recognition System
202   :id: ARCH_007
203   :status: closed
204   :links: REQ_010
205   :author: ALFRED
206
207   Design the system architecture for traffic sign recognition, including camera
208   capture, sign classification, and distribution of detected speed limits to vehicle control functions.
209
210   .. uml::
211
212      @startuml
213      node "Vehicle" {
214          component TrafficSignRecognition {
215              agent captureRoadScene
216              agent classifySpeedLimitSign
217          }
218          component FrontCamera {
219              agent streamFrames
220          }
221          component SignInterpreter {
222              agent extractSpeedLimit
223          }
224          component VehicleControl {
225              agent consumeSpeedLimit
226          }
227      }
228      FrontCamera --> TrafficSignRecognition
229      TrafficSignRecognition --> SignInterpreter
230      SignInterpreter --> VehicleControl
231      @enduml
232
233.. arch:: Blind Spot Monitoring System
234   :id: ARCH_008
235   :status: open
236   :links: REQ_011, REQ_012
237   :author: ALFRED
238
239   Define the system architecture for blind spot monitoring, combining rear-corner
240   radar coverage with side-view camera input, and routing occupancy state to the
241   driver alert system whenever the turn signal indicates an imminent lane change.
242
243   .. uml::
244
245      @startuml
246      node "Vehicle" {
247          component BlindSpotMonitor {
248              agent fuseSensorInputs
249              agent classifyZoneOccupancy
250          }
251          component RearCornerRadar {
252              agent detectApproachingObjects
253          }
254          component SideCamera {
255              agent captureBlindSpotImage
256          }
257          component TurnSignalSensor {
258              agent reportIntent
259          }
260          component DriverAlertSystem {
261              agent issueLaneChangeWarning
262          }
263      }
264      RearCornerRadar --> BlindSpotMonitor
265      SideCamera --> BlindSpotMonitor
266      TurnSignalSensor --> BlindSpotMonitor
267      BlindSpotMonitor --> DriverAlertSystem
268      @enduml
269
270.. arch:: Driver Drowsiness Detection System
271   :id: ARCH_009
272   :status: open
273   :links: REQ_013, REQ_014
274   :author: ALFRED
275
276   Define the system architecture for driver drowsiness detection, combining cabin
277   camera capture with an eye-state estimator and a drowsiness scorer that emits
278   progressive alerts via the existing driver alert system.
279
280   .. uml::
281
282      @startuml
283      node "Vehicle" {
284          component DrowsinessMonitor {
285              agent estimateEyeState
286              agent scoreDrowsiness
287          }
288          component CabinCamera {
289              agent captureDriverFace
290          }
291          component DrowsinessScorer {
292              agent updateScore
293          }
294          component DriverAlertSystem {
295              agent issueDrowsinessAlert
296              agent suggestBreak
297          }
298      }
299      CabinCamera --> DrowsinessMonitor
300      DrowsinessMonitor --> DrowsinessScorer
301      DrowsinessScorer --> DriverAlertSystem
302      @enduml
303
304.. arch:: Automated Parking System
305   :id: ARCH_010
306   :status: open
307   :links: REQ_015, REQ_016
308   :author: ALFRED
309
310   Define the system architecture for automated parking, combining ultrasonic ranging
311   and surround-view camera input for slot detection, a trajectory planner, and the
312   actuator interface that commands steering, throttle, and brake during the park maneuver.
313
314   .. uml::
315
316      @startuml
317      node "Vehicle" {
318          component ParkingAssist {
319              agent detectParkingSlot
320              agent planParkTrajectory
321              agent executeParkManeuver
322          }
323          component UltrasonicArray {
324              agent measureClearances
325          }
326          component SurroundCamera {
327              agent captureSlotImagery
328          }
329          component TrajectoryPlanner {
330              agent computeWaypoints
331          }
332          component VehicleActuators {
333              agent applySteeringThrottleBrake
334          }
335      }
336      UltrasonicArray --> ParkingAssist
337      SurroundCamera --> ParkingAssist
338      ParkingAssist --> TrajectoryPlanner
339      TrajectoryPlanner --> VehicleActuators
340      @enduml

SYS.3 Architecture Design