We believe in a free and open internet without borders, throttling, firewalls, blocks or restrictions. While still keeping you safe from those who want to harm you or steal your data.
Data-hungry companies around the world are selling your traffic stats, browsing and device data with their advertisers, which are stalking you across the web, thus making you a vitreous human lacking data-protection and privacy. We’re here to help! Learn more.
def reset_pid(self): """Reset PID controller state""" self.integral = 0 self.previous_error = 0 self.last_time = time.time()
def set_motor_speeds(self, base_speed, turn_speed): """ Calculate and set left/right motor speeds based on base speed and turn """ # Differential steering left_speed = base_speed + turn_speed right_speed = base_speed - turn_speed # Apply speed limits left_speed = max(-self.MAX_SPEED, min(self.MAX_SPEED, left_speed)) right_speed = max(-self.MAX_SPEED, min(self.MAX_SPEED, right_speed)) # Set motor speeds self.bot.set_left_motor_speed(left_speed) self.bot.set_right_motor_speed(right_speed)
print("\n=== MBot2 Line Follower ===") print("1. Quick start (default settings)") print("2. Run with calibration") print("3. Tune PID values") print("4. Exit")
def follow_line(self, duration=None): """ Main line following loop Args: duration: Time to follow line in seconds (None = run until stopped) """ print("Starting line follower...") print("Press Ctrl+C to stop") try: running = True start_time = time.time() while running: # Check duration if duration and (time.time() - start_time) >= duration: print(f"Completed duration seconds of line following") break # Read sensors sensors = self.read_line_sensors() position = self.calculate_line_position(sensors) # Calculate time delta for PID current_time = time.time() dt = current_time - self.last_time self.last_time = current_time if position is not None: # Line detected - follow it self.line_lost_timer = 0 # Calculate error (0 = center) error = position # Get PID output turn_speed = self.pid_control(error, dt) # Dynamic speed adjustment based on how centered we are # Slower on turns, faster on straight lines speed_factor = 1.0 - (abs(error) * 0.2) current_base_speed = max(self.MIN_SPEED, self.BASE_SPEED * speed_factor) # Set motor speeds self.set_motor_speeds(current_base_speed, turn_speed) # Debug output print(f"Pos: position:+.2f | Turn: turn_speed:+5.1f | " f"Speed: current_base_speed:5.1f | Sensors: sensors") else: # No line detected - handle line loss self.line_lost_timer += dt if self.line_lost_timer > self.EMERGENCY_STOP_TIME: print("Line lost for too long!") self.stop() if self.search_for_line(): # Reset PID state after finding line self.reset_pid() continue else: print("Cannot find line. Stopping.") break else: # Short line loss - just stop and wait self.stop() print("Waiting for line...") # Small delay to prevent overwhelming the system time.sleep(0.02) except KeyboardInterrupt: print("\nStopped by user") finally: self.stop() mbot2 line follower code
def stop(self): """Emergency stop - stops both motors""" self.bot.set_left_motor_speed(0) self.bot.set_right_motor_speed(0) print("Motors stopped")
""" MBot2 Line Follower Feature =========================== Uses the 5-channel line follower sensor to follow a black line on a white surface. Supports PID control for smooth tracking, speed adjustment, and emergency stop. """ import mbot2 import time import sys
def calculate_line_position(self, sensors): """ Calculate the line position as a weighted average Returns: position from -2.0 (far left) to +2.0 (far right), 0.0 = center, None if no line detected """ weighted_sum = 0 total_weight = 0 for i, reading in enumerate(sensors): if reading: # Line detected # Convert index to position: 0=-2, 1=-1, 2=0, 3=1, 4=2 position = i - 2 weighted_sum += position total_weight += 1 if total_weight > 0: return weighted_sum / total_weight else: return None # No line detected def reset_pid(self): """Reset PID controller state""" self
def search_for_line(self): """ When line is lost, search by rotating slowly Returns: True if line found, False if search timeout """ print("Line lost! Searching...") search_start = time.time() search_duration = 3 # Maximum search time (seconds) while time.time() - search_start < search_duration: sensors = self.read_line_sensors() position = self.calculate_line_position(sensors) if position is not None: print("Line found!") return True # Rotate slowly to search self.bot.set_left_motor_speed(self.MIN_SPEED) self.bot.set_right_motor_speed(-self.MIN_SPEED) time.sleep(0.05) print("Line search failed!") return False
class MBot2LineFollower: """Complete line follower implementation for MBot2 robot"""
def __init__(self): """Initialize the MBot2 robot and configure line follower""" self.bot = mbot2.MBot2() self.bot.start() # Sensor channels (0 = leftmost, 4 = rightmost) self.NUM_SENSORS = 5 # PID control parameters (tune these for your line type) self.KP = 0.35 # Proportional gain self.KI = 0.02 # Integral gain self.KD = 0.08 # Derivative gain # Speed settings self.BASE_SPEED = 30 # Base forward speed (0-100) self.MAX_SPEED = 50 # Maximum speed self.MIN_SPEED = 20 # Minimum speed to maintain movement # Line following state self.integral = 0 self.previous_error = 0 self.last_time = time.time() # Safety settings self.MAX_TURN = 70 # Maximum turning speed self.EMERGENCY_STOP_TIME = 0.5 # Time before emergency stop if line lost (seconds) self.line_lost_timer = 0 def read_line_sensors(self): """ Read all 5 line sensors Returns: list of 5 boolean values (True = line detected/black, False = white) """ # MBot2 line sensor returns values: 0=white, 1=black # Sensor order: [leftmost, left, center, right, rightmost] return [ self.bot.get_line_sensor(1), # Leftmost self.bot.get_line_sensor(2), # Left self.bot.get_line_sensor(3), # Center self.bot.get_line_sensor(4), # Right self.bot.get_line_sensor(5) # Rightmost ] Tune PID values") print("4
def tune_pid(self): """ Interactive PID tuning """ print("\n=== PID Tuning Mode ===") print("Adjust values to improve line following:") print(f"Current: KP=self.KP, KI=self.KI, KD=self.KD") while True: print("\nCommands:") print(" kp [value] - Set proportional gain") print(" ki [value] - Set integral gain") print(" kd [value] - Set derivative gain") print(" test - Test current settings") print(" quit - Exit tuning") cmd = input("> ").strip().lower() if cmd.startswith("kp"): try: self.KP = float(cmd.split()[1]) print(f"KP set to self.KP") except: print("Invalid value") elif cmd.startswith("ki"): try: self.KI = float(cmd.split()[1]) print(f"KI set to self.KI") except: print("Invalid value") elif cmd.startswith("kd"): try: self.KD = float(cmd.split()[1]) print(f"KD set to self.KD") except: print("Invalid value") elif cmd == "test": print("Testing for 5 seconds...") self.follow_line(duration=5) elif cmd == "quit": break else: print("Unknown command") def main(): """Main function to run the line follower with menu""" follower = MBot2LineFollower()
def pid_control(self, error, dt): """ PID control algorithm Returns: turn speed (-MAX_TURN to +MAX_TURN) """ # Proportional term p_term = self.KP * error # Integral term (with anti-windup) self.integral += error * dt # Limit integral to prevent excessive accumulation integral_limit = 100 self.integral = max(-integral_limit, min(integral_limit, self.integral)) i_term = self.KI * self.integral # Derivative term derivative = (error - self.previous_error) / dt if dt > 0 else 0 d_term = self.KD * derivative # Calculate total turn speed turn_speed = p_term + i_term + d_term # Limit turn speed turn_speed = max(-self.MAX_TURN, min(self.MAX_TURN, turn_speed)) # Store values for next iteration self.previous_error = error return turn_speed
choice = input("\nSelect option: ").strip()