ch-10 clean

ch-10/1-follow/follow.py

@@ -2,53 +2,54 @@ import time
 import robot
 import pid
 
+
 class FollowObject:
-  def __init__(self):
-    self.max_speed = 0.9
-    self.follow_pid = pid.PID(0.1, 0.1, 0.015, 15)
-    self.last_time = time.monotonic_ns()
-    self.left_dist = 0
-    self.pid_output = 0
+    def __init__(self):
+        self.max_speed = 0.9
+        self.follow_pid = pid.PID(0.1, 0.1, 0.015, 15)
+        self.last_time = time.monotonic()
+        self.left_dist = 0
+        self.pid_output = 0
 
-  def setup_robot(self):
-    robot.left_distance.distance_mode = 1
+    def setup_robot(self):
+        robot.left_distance.distance_mode = 1
 
-  def movement_update(self):
-    # do we have data
-    if robot.left_distance.data_ready:
-      self.left_dist = robot.left_distance.distance
-      
-      # calculate time delta
-      new_time = time.monotonic_ns()
-      time_delta = new_time - self.last_time
-      self.last_time = new_time
+    def movement_update(self):
+        # do we have data
+        if robot.left_distance.data_ready:
+            self.left_dist = robot.left_distance.distance
 
-      # get speeds from pid
-      self.pid_output = self.follow_pid.update(self.left_dist, time_delta)
-      speed = min(self.max_speed, self.pid_output)
-      speed = max(-self.max_speed, speed)
+            # calculate time delta
+            new_time = time.monotonic()
+            time_delta = new_time - self.last_time
+            self.last_time = new_time
 
-      # make movements
-      robot.set_left(speed)
-      robot.set_right(speed)
+            # get speeds from pid
+            self.pid_output = self.follow_pid.update(self.left_dist, time_delta)
+            speed = min(self.max_speed, self.pid_output)
+            speed = max(-self.max_speed, speed)
 
-      # reset and loop
-      robot.left_distance.clear_interrupt()
+            # make movements
+            robot.set_left(speed)
+            robot.set_right(speed)
 
-  def main_loop(self):
-    robot.left_distance.start_ranging()
-    self.last_time = time.monotonic()
-    while True:
-      self.movement_update()
+            # reset and loop
+            robot.left_distance.clear_interrupt()
+
+    def main_loop(self):
+        robot.left_distance.start_ranging()
+        while True:
+            self.movement_update()
+
+    def start(self):
+        print("Starting")
+        try:
+            self.setup_robot()
+            self.main_loop()
+        finally:
+            robot.stop()
+            robot.left_distance.clear_interrupt()
+            robot.left_distance.stop_ranging()
 
-  def start(self):
-    print("Starting")
-    try:
-      self.setup_robot()
-      self.main_loop()
-    finally:
-      robot.stop()
-      robot.left_distance.clear_interrupt()
-      robot.left_distance.stop_ranging()
 
 FollowObject().start()

ch-10/1-follow/pid.py

@@ -1,23 +1,23 @@
 class PID:
-  def __init__(self, proportional_k, integral_k, differential_k, set_point):
-    self.proportional_k = proportional_k    
-    self.integral_k = integral_k
-    self.differential_k = differential_k
-    self.set_point = set_point
+    def __init__(self, proportional_k, integral_k, differential_k, set_point):
+        self.proportional_k = proportional_k
+        self.integral_k = integral_k
+        self.differential_k = differential_k
+        self.set_point = set_point
 
-    self.error_sum = 0
-    self.last_value = 0
+        self.error_sum = 0
+        self.last_value = 0
 
-  def update(self, measurement, time_delta):
-    error_value = measurement - self.set_point
-    proportional = error_value * self.proportional_k
+    def update(self, measurement, time_delta):
+        error_value = measurement - self.set_point
+        proportional = error_value * self.proportional_k
 
-    # calculate integral
-    self.error_sum += error_value * time_delta
-    integral = self.error_sum * self.integral_k
-    self.last_value = error_value
+        # calculate integral
+        self.error_sum += error_value * time_delta
+        integral = self.error_sum * self.integral_k
+        self.last_value = error_value
 
-    differentiated_error = (error_value - self.last_value) / time_delta
-    differential = differentiated_error * self.differential_k
+        differentiated_error = (error_value - self.last_value) / time_delta
+        differential = differentiated_error * self.differential_k
 
-    return proportional + integral + differential
+        return proportional + integral + differential

ch-10/1-follow/pio_encoder.py

@@ -54,24 +54,24 @@ send:
 
 assembled = adafruit_pioasm.assemble(program)
 
-class QuadratureEncoder:
-  def __init__(self, first_pin, second_pin, reversed=False):
-    """Encoder with 2 pins. Must use sequential pins on the board"""
-    self.sm = rp2pio.StateMachine(
-        assembled,
-        frequency=0,
-        first_in_pin=first_pin,
-        jmp_pin=second_pin,
-        in_pin_count=2
-    )
-    self.reversed = reversed
-    self._buffer = array.array('i', [0])
 
-  def read(self):
-    while self.sm.in_waiting:
-      self.sm.readinto(self._buffer)
-    if self.reversed:
-      return -self._buffer[0]
-    else:
-      return self._buffer[0]
- 
+class QuadratureEncoder:
+    def __init__(self, first_pin, second_pin, reversed=False):
+        """Encoder with 2 pins. Must use sequential pins on the board"""
+        self.sm = rp2pio.StateMachine(
+            assembled,
+            frequency=0,
+            first_in_pin=first_pin,
+            jmp_pin=second_pin,
+            in_pin_count=2,
+        )
+        self.reversed = reversed
+        self._buffer = array.array("i", [0])
+
+    def read(self):
+        while self.sm.in_waiting:
+            self.sm.readinto(self._buffer)
+        if self.reversed:
+            return -self._buffer[0]
+        else:
+            return self._buffer[0]

ch-10/1-follow/robot.py

@@ -29,6 +29,7 @@ def stop():
     motor_B1.duty_cycle = 0
     motor_B2.duty_cycle = 0
 
+
 def set_speed(motor, speed):
     # Swap motor pins if we reverse the speed
     if speed < 0:
@@ -36,15 +37,16 @@ def set_speed(motor, speed):
         speed = -speed
     else:
         direction = motor
-    speed = min(speed, 1) # limit to 1.0
-    max_speed = 2**16-1
-
+    speed = min(speed, 1)  # limit to 1.0
+    max_speed = 2 ** 16 - 1
 
     direction[0].duty_cycle = int(max_speed * speed)
     direction[1].duty_cycle = 0
 
+
 def set_left(speed):
     set_speed(left_motor, speed)
 
+
 def set_right(speed):
     set_speed(right_motor, speed)