Method orbit

Software/Python/easygopigo3.py:517–593

Control the GoPiGo so it will orbit around an object. :param int degrees: Degrees to steer. **360** for full rotation. Negative for left turn. :param int radius_cm: Radius in `cm` of the circle to drive. Default is **0** (turn in place). :param boolean blo

(self, degrees, radius_cm=0, blocking=True)

    def orbit(self, degrees, radius_cm=0, blocking=True):
        """
        Control the GoPiGo so it will orbit around an object.  
        
        :param int degrees: Degrees to steer. **360** for full rotation. Negative for left turn.
        :param int radius_cm: Radius in `cm` of the circle to drive. Default is **0** (turn in place).
        :param boolean blocking = True: Set it as a blocking or non-blocking method.

        .. important:: 
           Note that while in non-blocking mode the speed cannot be changed before the end of the orbit as it would negate all orbit calculations. 
           After a non-blocking call, :py:meth:`~easygopigo3.EasyGoPiGo3.set_speed` has to be called before any other movement.
        """
        speed = self.get_speed()
        radius = radius_cm * 10

        # the total distance to drive in mm
        drive_distance = math.pi * abs(radius) * abs(degrees) / 180 # / 180 is shorter than radius * 2 / 360
        
        # the distance in mm to add to one motor and subtract from the other
        drive_difference = ((self.WHEEL_BASE_CIRCUMFERENCE * degrees) / 360)
        
        # the number of degrees each wheel needs to turn on average to get the necessary distance 
        distance_degrees = ((drive_distance / self.WHEEL_CIRCUMFERENCE) * 360)
        
        # the difference between motor travel in degrees
        difference_degrees = ((drive_difference / self.WHEEL_CIRCUMFERENCE) * 360)
        
        # the distance each wheel needs to turn
        left_target  = (distance_degrees + difference_degrees)
        right_target = (distance_degrees - difference_degrees)
        
        # if it's a left turn
        if degrees < 0:
            MOTOR_FAST = self.MOTOR_RIGHT
            MOTOR_SLOW = self.MOTOR_LEFT
            fast_target = right_target
            slow_target = left_target
        else:
            MOTOR_FAST = self.MOTOR_LEFT
            MOTOR_SLOW = self.MOTOR_RIGHT
            fast_target = left_target
            slow_target = right_target
        
        # determine driving direction from the speed
        direction = 1
        speed_with_direction = speed
        if speed < 0:
            direction = -1
            speed_with_direction = -speed
        
        # calculate the motor speed for each motor
        fast_speed = speed_with_direction
        slow_speed = abs((speed_with_direction * slow_target) / fast_target)
        
        # set the motor speeds
        self.set_motor_limits(MOTOR_FAST, dps = fast_speed)
        self.set_motor_limits(MOTOR_SLOW, dps = slow_speed)