Robotic Vacuum Algorithms Simulation (kulv05) - Revision history

Kulv05 at 22:18, 26 January 2025

2025-01-26T22:18:34Z

Kulv05 at 22:13, 26 January 2025

2025-01-26T22:13:06Z

Kulv05 at 22:08, 26 January 2025

2025-01-26T22:08:35Z

Show changes

Kulv05: /* Code */

2025-01-26T21:23:40Z

‎Code

Kulv05 at 21:16, 26 January 2025

2025-01-26T21:16:51Z

Kulv05 at 21:12, 26 January 2025

2025-01-26T21:12:54Z

Kulv05 at 20:59, 26 January 2025

2025-01-26T20:59:13Z

Kulv05 at 20:32, 26 January 2025

2025-01-26T20:32:12Z

Kulv05 at 20:27, 26 January 2025

2025-01-26T20:27:34Z

Kulv05 at 20:25, 26 January 2025

2025-01-26T20:25:43Z

@@ Line 249: / Line 249: @@
 The overall efficiency value of 1.57482E-06 or 1.574824(multiplied by 1000000) is exceptionally low, pointing to the limited practicality of the random walk algorithm for real-world applications. This value integrates multiple performance aspects, showing the algorithm's fundamental inefficiency.
 '''Conclusion'''
@@ Line 316: / Line 320: @@
 The higher overall efficiency score being 1.11064E-05 or 11.10639(multiplied by 1000000) indicates better optimization of resources. This value reflects a balance between energy, time, and cleaning effectiveness.
 '''Conclusion'''
@@ Line 377: / Line 385: @@
 The overall efficiency score is very low, being 3.43036E-06 or 3.430365(multiplied by 1000000), highlighting the algorithm’s struggle to balance time, energy, and cleaning results. While coverage is likely thorough, it comes at the expense of resource utilization.
 '''Conclusion'''
@@ Line 444: / Line 456: @@
 The overall efficiency value is 1.64817E-05 or 16.48171 (multiplied by 1000000). The overall efficiency score reflects the added resource demands, making Double Zigzag as efficient as its simpler counterpart, Zigzag.
 '''Conclusion'''
@@ Line 474: / Line 492: @@
 The overall efficiency value of 6.66426E-05 or 66.64261 (multiplied by 1000000) is significantly higher than the random walk algorithm's 1.57482E-06, highlighting the A* algorithm's substantial improvements in task performance across all key metrics.
 '''Conclusion'''

@@ Line 95: / Line 95: @@
 The trajectory was inspired by the "Improving robotic vacuum cleaners" article. [1]
-The algorithm, due to its nature, constanly loops near the walls, so to analyze the effitiency I decided to stop after 1000 ticks and apply all the formulas to see the results. It does not finish after all the trash was collected, but after 1000 ticks have passed.
+The algorithm, due to its nature, constanly loops near the walls, so to analyze the effitiency I decided to stop after 1000 ticks and apply all the formulas to see the results. It does not finish after all the trash was collected, but after 1000 ticks have passed. This is why one of the efficiency metrics for this algorithm is number of '''collected-trash'''.
@@ Line 132: / Line 132: @@
 If we imagine the spiral algorithm, when it moves in this specific way foe too long, it becomes the wall-to-wall algorithm and inherites its issues. This is why I decided to experiment with an alternative approach to the spiral algorithm by implementing a reverse spiral after the initial algorithm is not effective anymore. While the reverse spiral appears logically consistent, in practice, it often proves less effective. This is particularly evident in scenarios where the robot begins to re-cover areas that have already been cleaned. Although this algorithm may have utility under specific conditions, in my practical implementation, it demonstrated inferior performance compared to the random-walk algorithm. This suggests that in real-world applications, the reverse spiral may be outperformed by other cleaning strategies. What came to the metrics, they were worse than the values of the random walk algorithm and this is why I chose to mention it, but not include it into the report.
-The algorithm, due to its nature, constanly loops near the walls, so to analyze the effitiency I decided to stop after 2500 ticks and apply all the formulas to see the results. It does not finish after all the trash was collected, but after 2500 ticks have passed. The number of ticks is bigger then in the Wall-to-wall algorithm because the trajectory is more complex and more time is needed to reach the edges.
+The algorithm, due to its nature, constanly loops near the walls, so to analyze the effitiency I decided to stop after 2500 ticks and apply all the formulas to see the results. It does not finish after all the trash was collected, but after 2500 ticks have passed. The number of ticks is bigger then in the Wall-to-wall algorithm because the trajectory is more complex and more time is needed to reach the edges. This is why one of the efficiency metrics for this algorithm is number of '''collected-trash'''.
@@ Line 155: / Line 155: @@
 ==Zigzag==
-The algorithm, using the trajectory inspired by the "Improving robotic vacuum cleaners" article [1], due to its nature, constanly loops near the left, so to analyze the effitiency I decided to stop after 1000 ticks and apply all the formulas to see the results. It does not finish after all the trash was collected, but after 1000 ticks have passed.
+The algorithm, using the trajectory inspired by the "Improving robotic vacuum cleaners" article [1], due to its nature, constanly loops near the left, so to analyze the effitiency I decided to stop after 1000 ticks and apply all the formulas to see the results. It does not finish after all the trash was collected, but after 1000 ticks have passed. This is why one of the efficiency metrics for this algorithm is number of '''collected-trash'''.
 A zigzag algorithm uses the trajectory in which the robot moves around a room by alternating its direction of travel at an angle, typically 90 degrees, thereby creating a zigzag pattern. This approach allows the robot to cover the room area more evenly, especially in environments where there are obstacles or furniture.

@@ Line 511: / Line 511: @@
 =Code=
 [[File:Kulv05_randomwalk_algorithm.nlogo]]
 [[File:Kulv05_standart_walltowall_algorithm.nlogo]]
 [[File:Kulv05_walltowall_horiz_zigzag_algorithm.nlogo]]
 [[File:Kulv05_standartspiral_algorithm.nlogo]]
 [[File:Kulv05_spiral_horiz_zigzag_algorithm.nlogo]]
 [[File:Kulv05_standart_zigzag_algorithm.nlogo]]
 [[File:Kulv05_double_zigzag_algorithm.nlogo]]
 [[File:Kulv05_astar_algorithm.nlogo]]

@@ Line 173: / Line 173: @@
 SLAM, or Simultaneous Localization and Mapping, is an algorithm widely used by robots for autonomous navigation. It enables devices to simultaneously determine their position in space (localization) and create a map of the surrounding environment (mapping). [2] SLAM plays a crucial role in robotics, especially for systems operating in unfamiliar or dynamic environments, such as drones, autonomous vehicles, or robotic vacuum cleaners. SLAM stands out due to its ability to tackle two mentioned tasks simultaneously: '''localization'''  and '''mapping'''. It relies on data from sensors such as cameras or LiDARs and performs complex mathematical operations to interpret this information in real time. This dual functionality makes SLAM a powerful tool for enabling robots to navigate and understand their surroundings autonomously.
-Implementing SLAM in NetLogo, even with the Py-Extension, is extremely challenging due to NetLogo's limited computational power and lack of tools for processing sensor data (such as LiDARs or cameras). NetLogo is designed for simple agent-based modeling in a discrete environment, while SLAM requires complex mathematical computations, linear algebra, statistics, and work with continuous geometry.
+Implementing SLAM in NetLogo, even with the Py-Extension, is extremely challenging due to NetLogo's limited environment and lack of tools for processing sensor data (such as LiDARs or cameras). NetLogo is designed for simple agent-based modeling in a discrete environment, while SLAM requires complex mathematical computations, linear algebra, statistics, and work with continuous geometry.
 This algorithm can be conquered in agent based simulation, but probably using another simulator, for example MATLAB, would be more suitable. It can be a future improvement of the project.
-I would like to share my attempt and leave a draft for you. While this is not a fully functional algorithm, and despite not succeeding in completing the task due to my limited experience with NetLogo, I hope to at least spark your interest in my approach to solving this challenging problem, which ultimately proved too difficult for me.
+I would like to share my attempt and leave a draft for you. While this is '''not a fully functional algorithm and not a part of the simulation''', and despite not succeeding in completing the task due to my limited experience with NetLogo, I hope to at least spark your interest in my approach to solving this challenging problem, which ultimately proved too difficult for me.
 How Did I Attempt to Implement SLAM?

@@ Line 66: / Line 66: @@
 ====Collecting trash====
 =Model=
@@ Line 175: / Line 176: @@
 This algorithm can be conquered in agent based simulation, but probably using another simulator, for example MATLAB, would be more suitable. It can be a future improvement of the project.
 I would like to share my attempt and leave a draft for you. While this is not a fully functional algorithm, and despite not succeeding in completing the task due to my limited experience with NetLogo, I hope to at least spark your interest in my approach to solving this challenging problem, which ultimately proved too difficult for me.
 How Did I Attempt to Implement SLAM?
-Room Simulation in NetLogo:
+To start, I created a room simulation in NetLogo. The room included furniture, walls, and randomly scattered trash objects. The robot was equipped with "sensors" to scan its surroundings and send data to Python for processing. The idea was to use NetLogo for visualization and Python for the heavy computational work.
-I started by creating a room simulation in NetLogo, complete with furniture, walls, and randomly scattered objects (trash). The robot was equipped with "sensors" to scan its surroundings and send data to Python for processing.
+In Python, I implemented the logic for processing sensor data and controlling the robot’s movement. This included identifying nearby objects and updating the SLAM map. Each step of the robot involved collecting obstacle data, updating the SLAM map, and deciding the next movement based on the updated information. I used NetLogo’s py:run and py:set functions to integrate Python with NetLogo, allowing the robot to send sensor data to Python and receive movement instructions in return.
+The trash wasn’t just visually represented in the room—it was also integrated into the SLAM map. When the robot collected trash, it was removed from the patch, and the data was updated. Information about collected trash was sent to Python to remove it from the SLAM map, ensuring the map reflected the current state of the simulation. This dynamic updating was one of the more interesting parts of the project.
-Python for Data Processing and Logic:
+In Python, I created a map matrix that updated in real time based on sensor data. This matrix accounted for new obstacles and trash detected by the robot, providing a foundation for path planning. The robot’s movement logic included checking if a path was clear, adjusting the robot’s angle if the path was blocked, and planning a trajectory toward the nearest trash based on sensor data.
 I hope this draft inspires further exploration and experimentation, even if it serves as a reminder of the complexities involved in implementing advanced algorithms like SLAM.
 ----
@@ Line 241: / Line 203: @@
 =Results=
 ====Random Walk Results====
@@ Line 496: / Line 465: @@
 =Conclusion=
-This simulation provided a comprehensive analysis of '''8''' various movement algorithms for robotic vacuum cleaners, evaluating their performance based on key metrics such as cleaning speed, power consumption, and overall efficiency. The results highlight significant differences in the effectiveness of each algorithm, offering valuable insights into their practical applications.
+This simulation provided a comprehensive analysis of '''8''' various movement algorithms for robotic vacuum cleaners, evaluating their performance based on key metrics such as cleaning speed, power consumption, and overall efficiency. A few hybrid algorithms made it way to the simulation as well to enhanse the performance. The results highlight significant differences in the effectiveness of each algorithm, offering valuable insights into their practical applications.

@@ Line 170: / Line 170: @@
 ==SLAM (simultaneous localization and mapping)==
-[2]
+SLAM, or Simultaneous Localization and Mapping, is an algorithm widely used by robots for autonomous navigation. It enables devices to simultaneously determine their position in space (localization) and create a map of the surrounding environment (mapping). [2] SLAM plays a crucial role in robotics, especially for systems operating in unfamiliar or dynamic environments, such as drones, autonomous vehicles, or robotic vacuum cleaners. SLAM stands out due to its ability to tackle two mentioned tasks simultaneously: '''localization'''  and '''mapping'''. It relies on data from sensors such as cameras or LiDARs and performs complex mathematical operations to interpret this information in real time. This dual functionality makes SLAM a powerful tool for enabling robots to navigate and understand their surroundings autonomously.
 ----

@@ Line 156: / Line 156: @@
 ----
 ==Double Zigzag==
 [[File:Kulv05_doublezigzag.gif]]
@@ Line 434: / Line 440: @@
 =Conclusion=
@@ Line 453: / Line 461: @@
 . '''Wall-to-Wall''': Impractical as a stand alone algorithm due to its inefficiency. Cannot collect any trash other than the one on the path to the wall or near the walls.
 =Citations=
-[1]https://www.diva-portal.org/smash/get/diva2:1213349/FULLTEXT02.pdf
+[1] https://www.diva-portal.org/smash/get/diva2:1213349/FULLTEXT02.pdf
 [2] https://ouster.com/insights/blog/introduction-to-slam-simultaneous-localization-and-mapping

@@ Line 1: / Line 1: @@
 =Problem definition=
 The primary objective of this simulation is to thoroughly analyze and compare different movement algorithms designed for a robotic vacuum cleaner.
@@ Line 12: / Line 21: @@
 . '''Time Efficiency'''
 This metric measures how many ticks are required to collect a unit of trash. A lower value indicates faster trash collection.
@@ Line 17: / Line 27: @@
 . '''Power Efficiency'''
 This metric measures how much energy is consumed to collect a unit of trash. A lower value indicates better energy efficiency.
@@ Line 54: / Line 65: @@
 ====Collecting trash====
 =Model=
 ==Random Walk==
@@ Line 149: / Line 156: @@
 ----
 ==Double Zigzag==
 [[File:Kulv05_doublezigzag.gif]]
@@ Line 433: / Line 434: @@
 =Conclusion=
 . '''A*''': Fastest, most energy-efficient, and optimal for practical use.
@@ Line 455: / Line 453: @@
 . '''Wall-to-Wall''': Impractical as a stand alone algorithm due to its inefficiency. Cannot collect any trash other than the one on the path to the wall or near the walls.
 =Citations=
-[1] https://www.diva-portal.org/smash/get/diva2:1213349/FULLTEXT02.pdf
+[1]https://www.diva-portal.org/smash/get/diva2:1213349/FULLTEXT02.pdf
 [2] https://ouster.com/insights/blog/introduction-to-slam-simultaneous-localization-and-mapping

@@ Line 21: / Line 21: @@
 ''Power Efficiency = Energy / Collected Trash''
-. This metric combines both time and energy efficiency into a single value. A higher value indicates better overall performance.
+. '''Overall Efficiency'''
 ''Overall Efficiency = CollectedTrash /(Ticks needed to finish cleaning × Energy) ''
@@ Line 57: / Line 59: @@
 =Model=
 ==Random Walk==