Welcome to Shubham's Blog

The software was split into multiple files, each handling a specific task. For example, control.py handled the motors, face_recog.py handled face detection, and the main.py coordinated everything.

Lesson Learned: A well-organized modular approach is essential for complex projects. However, using multiple files requires careful management of multi-threading to ensure synchronization between tasks, especially when handling sensors, motors, and the camera simultaneously.

The Raspberry Pi needed to coordinate multiple tasks at once, which required handling multiple sensor inputs and controlling motors without delay. We tried using different approaches, like threading, to execute multiple functions simultaneously. However, the overall performance suffered due to limited CPU power and lack of efficient resource management.

Lesson Learned: concurrency and Multithreading can be difficult to manage in Python, especially on low-powered deices like the Raspberry Pi. If possible, use C++ for performance-heavy tasks or utilize framework like ROS for better Resource management. Or you can use Arduino uno or mega, to distribute the work load, like sensing and detection is done by the microcontroller and the processing and calculation is done by the Rapsberry Pi or the Single Board Computers , we can save some resources from memory side, plus this process generates less heat, but remember you need a good powersupply with longer backup

4. Obstacle Avoidance and Sensor Integration

We used 4 ultrasonic sensors (front-left, front-right, back-left, back-right) to handle obstacle avoidance. The robot would stop and reverse if both front sensors detected an obstacle. The back sensors would then guide the robot to turn., Also used a additional Head ultrasonic sensor on the front side of head top facing front, used when if obstacle detected it will trigger camera to check for human for safety

Lesson Learned: Sensor placement is critical for accurate obstacle detection. The robot’s movement patterns should be thoroughly tested in different environments to ensure the sensors are positioned correctly for optimal detection.

The Robot initially used a 12 volt motor controlled ia L298N motor driver. one of controlling forward and Revserse and another for steering mechanism (left and right) , lets say a logic like 2 second clock wise and 2 second anticlockwise, and mechanism was made such a way that it will center it self(the mechanical part)

Lesson Learned The L298N motor driver was actually effecient and can take heavy load for this project, rest motor driver like DR8833 smoked out during tests (under room temperature), but using a servo motor for this steering purpose can be worth it ( opt for a heavy one like capacity more then 30kg)

5.Face Recognition And Speech Processing:

We used OpenCV and dlib to implement basic face recognition. The robot could detect a face, recognize it from a database, and greet the person by name. The database stored 15 samples of each person, compiled into a pickle file for face recognition.

Lesson Learned: While OpenCV and dlib provide powerful tools for face detection and recognition, they can be computationally intensive on the Raspberry Pi. Consider using optimized versions or offloading processing to a more powerful system if real-time performance is critical.

The Robot greeted the user using the text-to-speech(TTS), we initially used Google Text-to-Speech or pyttsx3 to generate speech from text, basically a prewritten code with some special instructions alinged to it, and the peice of programming will trigger that will activate this speech program

Lesson Learned: Speech Processing required significant CPU and memory resources, if Possible , pre-generated speech samples (as we did with our pre-recording greetings) to avoid real-time TTS delays.

6. Key Takeaways and Lessons Learned:

(A)Power Consideration:

Ensure that your power source can handle the total power consumption, especially when running a power-hungry device like the Raspberry Pi 4B. Lithium-ion batteries are preferable for robotics projects due to their lighter weight and better energy density compared to lead-acid batteries. Always match the charger's current rating with the battery's requirements.

(B) Choosing the Right tools for the Job:

Python is great for high-level tasks (e.g., face recognition, speech synthesis), but consider using C++ for time-sensitive tasks like motor control and sensor processing to optimize performance. Use ROS if you're working on complex robotics projects with multiple sensors and actuators. It will help you handle concurrency, communication, and hardware abstraction efficiently.

(C) Modular and Scalable Software Design:

Break down your code into manageable modules and ensure synchronization between threads or processes. This will help keep the project organized and scalable for future enhancements. Consider using event-driven programming or state machines for handling complex behaviors in robotics systems.

(D) Testing and Debugging:

Test each module independently (e.g., motor control, face recognition) before integrating them into the final system. Debugging robotics projects can be difficult because you're working with both software and hardware. Make sure to have a methodical approach to track issues, from sensor calibration to motor control.