refactor(cytron): replace wiringpi with RPi.GPIO

- `wiringpi` is now deprecated, replace it with `RPi.GPIO`
    as used in the rest of robot library.

Author: OldUser101

robot/cytron.py

@@ -1,45 +1,26 @@
-"""An interface to the cyctron motor board. A gpio pin is used for each motor
+"""
+An interface to the cyctron motor board. A GPIO pin is used for each motor
 to give direction and has a PWM signal at 100Hz giving infomation about voltage
 to apply
 """
-import wiringpi as wp
+
+import RPi.GPIO as GPIO
 from .greengiant import clamp
 
 _MAX_OUTPUT_VOLTAGE = 12
 
-_PWM_PIN_1 = 26
-_PWM_PIN_2 = 23
-_DIR_PIN_1 = 25
-_DIR_PIN_2 = 5
-
-_WP_OUT = 1
-_WP_PWM = 2
-
-# Wiring pi's PWM has range 0-1024 but we want to present a range of 0-100
-_WP_PWM_MAX = 1024
-_RC_PWM_MAX = 100
-
-
-def wp_to_rc_pwm(wp_pwm):
-    """Convert from wiring pi's numbering to percentages"""
-    return (wp_pwm * _RC_PWM_MAX)/_WP_PWM_MAX
-
-
-def rc_to_wp_pwm(rc_pwm):
-    """Convert from percenatges to wiring pi's numbering"""
-    return int((rc_pwm * _WP_PWM_MAX)/_RC_PWM_MAX)
+_PWM_PIN_1 = 12
+_PWM_PIN_2 = 13
+_DIR_PIN_1 = 26
+_DIR_PIN_2 = 24
 
-
-class CytronBoard():
+class CytronBoard:
     def __init__(self, max_motor_voltage):
-        """The interface to the CytronBoard
+        """
+        The interface to the CytronBoard
         max_motor_voltage - The motors will be scaled so that this is the maxium
-                            average voltage the Cyctron will output
+                            average voltage the Cytron will output
         """
-        # Set up Wiring Pi following the wiring pi numbering scheme
-        if wp.wiringPiSetup() != 0:
-            raise RuntimeError("Failed to init Wiring Pi")
-
         if not (0 <= max_motor_voltage <= 12):
             raise ValueError("max_motor_voltage must satisfy 0 <= "
                              "max_motor_voltage <= 12 but instead is "
@@ -50,49 +31,50 @@ def __init__(self, max_motor_voltage):
         self.power_scaling_factor = (
             max_motor_voltage / _MAX_OUTPUT_VOLTAGE) ** 2
 
-        self._percentages = [0, 0]
-        self._dir = [_DIR_PIN_1, _DIR_PIN_2]
-        self._pwm_pins = [_PWM_PIN_1, _PWM_PIN_2]
-
-        wp.pinMode(_DIR_PIN_1, _WP_OUT)
-        wp.pinMode(_DIR_PIN_2, _WP_OUT)
-        wp.pinMode(_PWM_PIN_1, _WP_PWM)
-        wp.pinMode(_PWM_PIN_2, _WP_PWM)
-
-        wp.pwmSetClock(3000)
-        for pin in self._pwm_pins:
-            wp.pwmWrite(pin, 0)
+        self._dir = [
+            (GPIO.LOW, _DIR_PIN_1),
+            (GPIO.LOW, _DIR_PIN_2),
+        ]
+        self._pwm = [
+            (0, GPIO.PWM(_PWM_PIN_1, 100)),
+            (0, GPIO.PWM(_PWM_PIN_2, 100)),
+        ]
+
+        GPIO.setmode(GPIO.BCM)
+        GPIO.setup(_DIR_PIN_1, GPIO.OUT)
+        GPIO.setup(_DIR_PIN_2, GPIO.OUT)
+        GPIO.setup(_PWM_PIN_1, GPIO.OUT)
+        GPIO.setup(_PWM_PIN_2, GPIO.OUT)
 
     def __getitem__(self, index):
-        """Returns the current PWM value in RC units. Adds a sign to represent"""
-        if index not in (1, 2):
+        """Returns current motor PWM value as a percentage"""
+        if index not in (0, 1):
             raise IndexError(
-                f"motor index must be in (1,2) but instead got {index}")
+                f"Motor index must be in (0,1) but instead got {index}")
 
-        index -= 1
-        return self._percentages[index]
+        return self._pwm[index][0]
 
     def __setitem__(self, index, percent):
-        """Clamps input value, converts from percentage to wiring pi format and
-        sets a PWM format"""
-        if index not in (1, 2):
+        """Set current motor PWM percentage value"""
+        if index not in (0, 1):
             raise IndexError(
-                f"motor index must be in (1,2) but instead got {index}")
+                f"Motor index must be in (0,1) but instead got {index}")
 
-        index -= 1
-        percent = clamp(percent, -100, 100)
-        self._percentages[index] = percent
+        if percent < 0:
+            self._dir[index][0] = GPIO.LOW
+        else:
+            self._dir[index][0] = GPIO.HIGH
 
-        direction = (percent < 0)
-        wp.digitalWrite(self._dir[index], direction)
+        GPIO.output(self._dir[index][1], self._dir[index][0])
+
+        percent = clamp(percent, -100, 100)
+        self._pwm[index][0] = percent
 
-        # Scale such that 50% with a motor limit of 6V is really 3V
-        scaled_value = abs(percent) * self.power_scaling_factor
-        wp_value = rc_to_wp_pwm(scaled_value)
-        wp.pwmWrite(self._pwm_pins[index], wp_value)
+        percent = abs(percent) * self.power_scaling_factor
+        self._pwm[index][1].start(percent)
 
     def stop(self):
         """Turns motors off"""
-        for pwm_pin, percentage in zip(self._pwm_pins, self._percentages):
-            wp.pwmWrite(pwm_pin, 0)
-            percentage = 0
+        for i in range(len(self._pwm)):
+            self._pwm[i][0] = 0
+            self._pwm[i][1].start(0)