I had the same issue but using an ESP32 with an I2C servo controller. The I2C servo controller has two power inputs, one to power the board itself and the other to power the servos. To power the board itself, I am using a 5V buck which is powered by the main battery. To power the servos, I am using a Henge 8A switching UBEC which is also powered by the main battery. All of the ground wires are connected to the main battery ground using a terminal block.

Followed step by step. It appears to not have the right response. The web service shuts down and an invalid syntax error occurs when running the python3 ~/walle-replica/web_interface/app.py to check for errors.

 File “/home/walle-replica/web_interface/app.py”, line 27
  from flask import Flask, …, Response # Add Response
               ^^^
SyntaxError: invalid syntax

I have tried these changes and it did not work. It seemed to stop the web interface service and gives an internal server error message.

Guide: Implementing Face Tracking for WALL-EThis guide outlines how to enable Face Tracking on your WALL-E robot using OpenCV. This feature allows WALL-E to detect a human face and automatically rotate its head to follow the movement.
1. PrerequisitesEnsure that the OpenCV data files (Haar Cascades) are installed on your Raspberry Pi.
Bash

sudo apt install opencv-data -y

2. Locate Data FileFind the absolute path of the haarcascade_frontalface_default.xml file, as the system might not locate it automatically.
Bash

find /usr -name "haarcascade_frontalface_default.xml"
# Common path: /usr/share/opencv4/haarcascades/haarcascade_frontalface_default.xml

3. Modify Backend (app.py)Update the USBCameraStreamer class in web_interface/app.py to include the face detection and tracking logic.
A. Initialization (__init__)Load the Haar Cascade model using the absolute path found in Step 2 and initialize the head position variable.
Python

def __init__(self):
    self.camera = cv2.VideoCapture(0)
    # Load the face detection model using the absolute path
    self.face_cascade = cv2.CascadeClassifier('/usr/share/opencv4/haarcascades/haarcascade_frontalface_default.xml')
    self.is_running = False
    self.head_pos = 50  # Initial head position (Center)

B. Tracking Logic (get_frame)Implement the logic to detect faces and send servo commands to the Arduino.
Python

def get_frame(self):
    if self.is_running:
        success, frame = self.camera.read()
        if success:
            # 1. Convert to grayscale for performance
            gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
            
            # 2. Detect faces
            faces = self.face_cascade.detectMultiScale(gray, 1.1, 4)

            for (x, y, w, h) in faces:
                # Draw a rectangle around the face
                cv2.rectangle(frame, (x, y), (x+w, y+h), (255, 0, 0), 2)
                
                # 3. Calculate the center of the face
                x_center = x + (w / 2)
                
                # 4. Control Motors (Center is 320, Deadzone is 40px)
                global arduino
                
                # If face is on the left -> Rotate head left (Decrease angle)
                if x_center < 280: 
                    if self.head_pos > 0:
                        self.head_pos -= 1
                        arduino.send_command("G" + str(self.head_pos))
                        
                # If face is on the right -> Rotate head right (Increase angle)
                elif x_center > 360: 
                    if self.head_pos < 100:
                        self.head_pos += 1
                        arduino.send_command("G" + str(self.head_pos))

            ret, buffer = cv2.imencode('.jpg', frame)
            return buffer.tobytes()
    return None

4. Run & TestRestart the WALL-E service to apply the changes.
Bash

sudo systemd restart walle.service
sudo systemd status walle.service

• Note: Verify that the service status is active (running).

️ Guide: Enabling USB Camera Support for WALL-E 
This guide outlines the steps to replace the default PiCamera module with a USB Webcam using OpenCV in the WALL-E Flask web interface. ( by Gemini )
 
1. Prerequisites 
First, install the OpenCV library for Python on your Raspberry Pi.
Bash

sudo apt update
sudo apt install python3-opencv

 
2. Modify Backend (app.py) 
We need to update the Python Flask server to capture frames from the USB camera.
A. Import OpenCV and Response Add cv2 and Response to the imports at the top of the file.
Python

from flask import Flask, ..., Response  # Add Response
import cv2                              # Add cv2

B. Add Camera Class Insert the USBCameraStreamer class before the app = Flask(__name__) line.
Python

class USBCameraStreamer:
    def __init__(self):
        self.camera = cv2.VideoCapture(0) # 0 is usually the default USB camera
        self.is_running = False

    def start_stream(self):
        if not self.camera.isOpened():
            self.camera.open(0)
        self.is_running = True
        return True, "USB Camera Started"

    def stop_stream(self):
        self.is_running = False
        if self.camera.isOpened():
            self.camera.release()
        return True

    def is_stream_active(self):
        return self.is_running

    def get_frame(self):
        if self.is_running:
            success, frame = self.camera.read()
            if success:
                ret, buffer = cv2.imencode('.jpg', frame)
                return buffer.tobytes()
        return None

C. Initialize Camera Replace the existing PiCameraStreamer initialization with our new class (around line 34).
Python

# camera: PiCameraStreamer = PiCameraStreamer()  <-- Comment this out
camera = USBCameraStreamer()                     # <-- Add this

D. Add Video Route Add the generator function and route at the bottom of the file (before if __name__ == ...).
Python

def gen(camera):
    while True:
        frame = camera.get_frame()
        if frame is not None:
            yield (b'--frame\r\n'
                   b'Content-Type: image/jpeg\r\n\r\n' + frame + b'\r\n')
        else:
             time.sleep(0.1)

@app.route('/video_feed')
def video_feed():
    return Response(gen(camera),
                    mimetype='multipart/x-mixed-replace; boundary=frame')

 
3. Modify Frontend (index.html) 
Update the HTML to load the video from our new route.

• File: web_interface/templates/index.html
• Action: Find the <img> tag with id="stream" and change the src attribute.

HTML

<img id="stream" src="{{ url_for('static', filename='streamimage.jpg') }}">

<img id="stream" src="{{ url_for('video_feed') }}">

 
4. Update Logic (main.js) 
Prevent the JavaScript from overwriting the camera URL with the old port 8080 address.

• File: web_interface/static/js/main.js
• Action: Search for $("#stream").attr("src", ...) and replace the URL in two places (inside sendSettings function and window.onload section).

JavaScript

// Replace this logic in both locations:
$("#stream").attr("src", "/video_feed");

 
5. Run 
Restart the service to apply changes.
Bash

sudo systemd stop walle.service
python3 app.py