Fixed a few issues including switching to auto mode from manual after recording if there is already a detection. Correct default cofiguration. Add a seperate calibration program (still needs more work). Added a hard coded slow move when going back to home position as could be extreme movement depending on the last tracked movement position. Add gitattributes so large doc files/images not included in release.

Author: Dave

.gitattributes

@@ -0,0 +1,3 @@
+docs/ export-ignore
+Pimoroni_pan_tilt_hat/ export-ignore
+README.md export-ignore

calibrate_web.py

@@ -0,0 +1,136 @@
+#!/usr/bin/env python3
+"""
+calibrate_web.py
+
+A web-based calibration tool for adjusting the degree movement per pixel.
+It uses Picamera2 to capture images, a Flask web server to serve a web page,
+and allows you to click on the image to specify a target point.
+The script then calculates the required pan/tilt adjustments (using the same
+calculation as in your main program) and moves the camera.
+After the move, a new image is shown for comparison.
+
+On startup, the camera is moved to its home position (as defined in your configuration).
+"""
+
+import time
+import cv2
+from flask import Flask, render_template, Response, request, jsonify
+from picamera2 import Picamera2
+import pan_tilt_control  # Your pan/tilt control module
+import my_configuration as config  # Your configuration file
+
+# Calibration parameters from configuration
+PAN_DEG_PER_PIXEL = config.PAN_DEG_PER_PIXEL
+TILT_DEG_PER_PIXEL = config.TILT_DEG_PER_PIXEL
+PAN_INVERT = config.PAN_INVERT
+TILT_INVERT = config.TILT_INVERT
+
+app = Flask(__name__)
+
+# Initialize and configure Picamera2 using the resolution from your config.
+# (Your main program uses config.MAIN_STREAM_RESOLUTION for configuration.)
+picam2 = Picamera2()
+preview_config = picam2.create_preview_configuration(main={"size": config.MAIN_STREAM_RESOLUTION})
+picam2.configure(preview_config)
+picam2.start()
+time.sleep(1)  # Allow time for auto exposure/white balance to settle
+
+# Get the actual main stream resolution (this should match what your main program uses)
+main_resolution = picam2.stream_configuration("main")["size"]
+
+
+@app.route("/")
+def index():
+    # Render the calibration page, passing the actual main resolution and a timestamp.
+    return render_template("index_calibrate.html",
+                           timestamp=time.time(),
+                           main_resolution=main_resolution)
+
+
+@app.route("/capture_image")
+def capture_image():
+    """
+    Capture an image from the camera and return it as a JPEG.
+    This endpoint is used by the web page to populate the canvases.
+    """
+    try:
+        img = picam2.capture_array("main")
+    except Exception as e:
+        return f"Error capturing image: {e}", 500
+
+    ret, jpeg = cv2.imencode('.jpg', img)
+    if not ret:
+        return "Failed to encode image", 500
+    return Response(jpeg.tobytes(), mimetype="image/jpeg")
+
+
+@app.route("/calibrate", methods=["POST"])
+def calibrate():
+    """
+    Receives JSON data with the clicked (x, y) coordinates (in full-resolution pixels),
+    calculates the offset from the center of the main stream (as computed by the camera),
+    applies the degrees-per-pixel conversion (with inversion if needed), and commands
+    the camera to move.
+
+    Returns:
+      - The current angles,
+      - The pixel offset (x and y),
+      - The calculated delta (in degrees),
+      - The new angles,
+      - And a message.
+    """
+    data = request.get_json()
+    if not data or "x" not in data or "y" not in data:
+        return jsonify({"error": "Missing coordinates"}), 400
+
+    try:
+        x = float(data["x"])
+        y = float(data["y"])
+    except Exception:
+        return jsonify({"error": "Invalid coordinates"}), 400
+
+    main_w, main_h = main_resolution
+    center_x = main_w / 2.0
+    center_y = main_h / 2.0
+
+    # Compute the pixel offset from the center (exactly as in your main code)
+    offset_x = x - center_x
+    offset_y = y - center_y
+
+    # Calculate the required angle adjustments (in degrees)
+    delta_pan = offset_x * PAN_DEG_PER_PIXEL
+    delta_tilt = offset_y * TILT_DEG_PER_PIXEL
+    if PAN_INVERT:
+        delta_pan = -delta_pan
+    if TILT_INVERT:
+        delta_tilt = -delta_tilt
+
+    # Get current angles from your pan_tilt_control module
+    current_pan, current_tilt = pan_tilt_control.get_current_angles()
+    new_pan = current_pan + delta_pan
+    new_tilt = current_tilt + delta_tilt
+
+    # Command the camera to move to the new angles (using your existing move_to function)
+    pan_tilt_control.move_to(new_pan, new_tilt)
+    time.sleep(2)  # Allow time for the move to complete
+
+    response = {
+        "current_angles": {"pan": current_pan, "tilt": current_tilt},
+        "pixel_offset": {"x": offset_x, "y": offset_y},
+        "delta": {"pan": delta_pan, "tilt": delta_tilt},
+        "new_angles": {"pan": new_pan, "tilt": new_tilt},
+        "message": "Camera moved. See the updated view below."
+    }
+    return jsonify(response)
+
+
+if __name__ == "__main__":
+    # On startup, move the camera to its home position as specified in your config.
+    # If HOME_PAN or HOME_TILT are not defined, default to 0.
+    home_pan = getattr(config, "HOME_PAN", 0)
+    home_tilt = getattr(config, "HOME_TILT", 0)
+    print(f"Moving camera to home position: pan {home_pan}, tilt {home_tilt}")
+    pan_tilt_control.move_to(home_pan, home_tilt)
+
+    # Run the Flask app with the reloader disabled to prevent double initialization.
+    app.run(host="0.0.0.0", port=5000, debug=True, use_reloader=False)

main.py

@@ -487,6 +487,7 @@ def set_mode():
     mode = request.args.get("mode", "auto")
     if mode.lower() == "auto":
         water_pistol.stop()
+        target_tracker.reset()
         pan_tilt_control.move_to(HOME_PAN, HOME_TILT, steps=MOVE_STEPS, step_delay=MOVE_STEP_DELAY)
         auto_mode = True
         logger.info("Switched to AUTO mode")
@@ -592,13 +593,16 @@ def __init__(self, move_steps, move_step_delay):
         self.move_steps = move_steps
         self.move_step_delay = move_step_delay
         # Move to home on init
+        time.sleep(1.0)
         self.home()
 
     def home(self):
         pan_tilt_control.move_to(
             HOME_PAN, HOME_TILT,
-            steps=self.move_steps,
-            step_delay=self.move_step_delay
+            # steps=self.move_steps,
+            # step_delay=self.move_step_delay
+            steps=10,
+            step_delay=0.1
         )
 
     def set_target_by_pixels(self, offset_x, offset_y):
@@ -635,8 +639,10 @@ def do_home():
             self.is_moving = True
             pan_tilt_control.move_to(
                 HOME_PAN, HOME_TILT,
-                steps=self.move_steps,
-                step_delay=self.move_step_delay
+                # steps=self.move_steps,
+                # step_delay=self.move_step_delay
+                steps=10,
+                step_delay=0.1
             )
             self.is_moving = False
         threading.Thread(target=do_home, daemon=True).start()
@@ -728,6 +734,14 @@ def update_detections(self, has_detections):
     def is_target_acquired(self):
         return self.target_acquired
 
+    def reset(self):
+        # Force a fresh
+        self.detection_timestamps.clear()
+        self.target_acquired = False
+        self.last_detection_time = None
+
+        logger.info("[TargetTracker] State has been reset.")
+
 # Simple detection container
 class Detection:
     def __init__(self, coords, category, conf, metadata, picam2, imx500):

my_configuration.py

@@ -29,8 +29,8 @@
 REPLAY_PIN = 14
 
 # How many degrees to move per pixel offset when tracking an object
-PAN_DEG_PER_PIXEL = 0.016
-TILT_DEG_PER_PIXEL = 0.016
+PAN_DEG_PER_PIXEL = 0.044
+TILT_DEG_PER_PIXEL = 0.045
 
 # Reverse directions if needed (if you go up instead of down and left instead of right)
 PAN_INVERT = True  # If True, pan movement is inverted
@@ -52,8 +52,8 @@
 HOME_TILT = 20.0
 
 # Move smoothing, adjust to make the movement smoother or more aggressive
-MOVE_STEPS = 1
-MOVE_STEP_DELAY = 0.00
+MOVE_STEPS = 5
+MOVE_STEP_DELAY = 0.05
 
 # Fire water pistol on detections
 WATER_PISTOL_ARMED = True

templates/index_calibrate.html

@@ -0,0 +1,149 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>Camera Calibration Tool</title>
+  <style>
+    body { font-family: Arial, sans-serif; margin: 20px; }
+    canvas { border: 1px solid #333; margin-bottom: 20px; }
+    #beforeContainer, #afterContainer { margin-bottom: 30px; }
+    #instructions { margin-bottom: 20px; }
+  </style>
+</head>
+<body>
+  <h1>Camera Calibration Tool</h1>
+  <div id="instructions">
+    <p><strong>Step 1:</strong> The top canvas shows the current camera image with a green cross marking its center.</p>
+    <p>Click on the image where you want that center to be relocated (your target point). A second green cross will appear at that point.</p>
+  </div>
+
+  <div id="beforeContainer">
+    <h2>Before Movement</h2>
+    <canvas id="beforeCanvas"></canvas>
+  </div>
+
+  <div id="afterContainer" style="display: none;">
+    <h2>After Movement</h2>
+    <canvas id="afterCanvas"></canvas>
+  </div>
+
+  <div id="results"></div>
+
+  <script>
+    // Use the main resolution passed from the server.
+    const imageWidth = {{ main_resolution[0] }};
+    const imageHeight = {{ main_resolution[1] }};
+
+    // Set up canvases.
+    const beforeCanvas = document.getElementById("beforeCanvas");
+    const afterCanvas = document.getElementById("afterCanvas");
+    beforeCanvas.width = imageWidth;
+    beforeCanvas.height = imageHeight;
+    afterCanvas.width = imageWidth;
+    afterCanvas.height = imageHeight;
+
+    const beforeCtx = beforeCanvas.getContext("2d");
+    const afterCtx = afterCanvas.getContext("2d");
+
+    // Global variable to store the clicked coordinate (in full resolution).
+    let clickedCoord = null;
+
+    // Load an image from /capture_image.
+    function loadCapture(callback) {
+      const img = new Image();
+      img.onload = function() {
+        callback(img);
+      };
+      // Add a timestamp to bypass caching.
+      img.src = "/capture_image?ts=" + new Date().getTime();
+    }
+
+    // Draw a green cross at the center of the canvas.
+    function drawCenterCross(ctx, width, height) {
+      ctx.strokeStyle = "lime";
+      ctx.lineWidth = 2;
+      const centerX = width / 2;
+      const centerY = height / 2;
+      const size = 10;
+      ctx.beginPath();
+      ctx.moveTo(centerX - size, centerY);
+      ctx.lineTo(centerX + size, centerY);
+      ctx.moveTo(centerX, centerY - size);
+      ctx.lineTo(centerX, centerY + size);
+      ctx.stroke();
+    }
+
+    // Draw a green cross at a given (x, y) coordinate.
+    function drawClickCross(ctx, x, y) {
+      ctx.strokeStyle = "lime";
+      ctx.lineWidth = 2;
+      const size = 10;
+      ctx.beginPath();
+      ctx.moveTo(x - size, y);
+      ctx.lineTo(x + size, y);
+      ctx.moveTo(x, y - size);
+      ctx.lineTo(x, y + size);
+      ctx.stroke();
+    }
+
+    // Draw the "before" image with overlays.
+    function drawBeforeImage() {
+      loadCapture(function(img) {
+        beforeCtx.clearRect(0, 0, imageWidth, imageHeight);
+        beforeCtx.drawImage(img, 0, 0, imageWidth, imageHeight);
+        drawCenterCross(beforeCtx, imageWidth, imageHeight);
+        // If a click has been made, mark that point.
+        if (clickedCoord) {
+          drawClickCross(beforeCtx, clickedCoord.x, clickedCoord.y);
+        }
+      });
+    }
+
+    // Initially load the before image.
+    drawBeforeImage();
+
+    // Handle clicks on the before canvas.
+    beforeCanvas.addEventListener("click", function(event) {
+      const rect = beforeCanvas.getBoundingClientRect();
+      // Convert the click coordinates to full-resolution coordinates.
+      const clickX = (event.clientX - rect.left) * (imageWidth / beforeCanvas.clientWidth);
+      const clickY = (event.clientY - rect.top) * (imageHeight / beforeCanvas.clientHeight);
+      clickedCoord = { x: clickX, y: clickY };
+
+      // Redraw the before image with the clicked cross.
+      drawBeforeImage();
+
+      // Send the clicked coordinates to the server for calibration.
+      fetch("/calibrate", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ x: clickX, y: clickY })
+      })
+      .then(response => response.json())
+      .then(data => {
+        // Display calibration details.
+        document.getElementById("results").innerHTML = `
+          <p><strong>Current Angles:</strong> Pan ${data.current_angles.pan.toFixed(2)}°, Tilt ${data.current_angles.tilt.toFixed(2)}°</p>
+          <p><strong>Pixel Offset:</strong> X: ${data.pixel_offset.x.toFixed(0)} pixels, Y: ${data.pixel_offset.y.toFixed(0)} pixels</p>
+          <p><strong>Delta (Angle Adjustment):</strong> Pan ${data.delta.pan.toFixed(2)}°, Tilt ${data.delta.tilt.toFixed(2)}°</p>
+          <p><strong>New Angles:</strong> Pan ${data.new_angles.pan.toFixed(2)}°, Tilt ${data.new_angles.tilt.toFixed(2)}°</p>
+          <p>${data.message}</p>
+        `;
+
+        // Show the after canvas and load the new image.
+        document.getElementById("afterContainer").style.display = "block";
+        loadCapture(function(imgAfter) {
+          afterCtx.clearRect(0, 0, imageWidth, imageHeight);
+          afterCtx.drawImage(imgAfter, 0, 0, imageWidth, imageHeight);
+          drawCenterCross(afterCtx, imageWidth, imageHeight);
+        });
+      })
+      .catch(err => {
+        console.error("Error:", err);
+        document.getElementById("results").innerText = "Error: " + err;
+      });
+    });
+  </script>
+</body>
+</html>
+