Remove single-letter variables

Author: RealOrangeOne

docs/programming/arduino.md

@@ -13,7 +13,7 @@ The Arduino can be accessed using the `arduino` property of the `Robot`
 object.
 
 ``` python
-my_arduino = r.arduino
+my_arduino = robot.arduino
 ```
 
 You can use the GPIO *(General Purpose Input/Output)* pins for anything,
@@ -43,7 +43,7 @@ performing an action with that pin. You can read about the possible pin
 modes below.
 
 ``` python
-r.arduino.pins[3].mode = GPIOPinMode.DIGITAL_INPUT_PULLUP
+robot.arduino.pins[3].mode = GPIOPinMode.DIGITAL_INPUT_PULLUP
 ```
 
 ### `GPIOPinMode.DIGITAL_INPUT`
@@ -52,9 +52,9 @@ In this mode, the digital state of the pin (whether it is high or low)
 can be read.
 
 ``` python
-r.arduino.pins[4].mode = GPIOPinMode.DIGITAL_INPUT
+robot.arduino.pins[4].mode = GPIOPinMode.DIGITAL_INPUT
 
-pin_value = r.arduino.pins[4].digital_state
+pin_value = robot.arduino.pins[4].digital_state
 ```
 
 ### `GPIOPinMode.DIGITAL_INPUT_PULLUP`
@@ -64,21 +64,21 @@ resistor](https://learn.sparkfun.com/tutorials/pull-up-resistors)
 enabled.
 
 ``` python
-r.arduino.pins[4].mode = GPIOPinMode.DIGITAL_INPUT_PULLUP
+robot.arduino.pins[4].mode = GPIOPinMode.DIGITAL_INPUT_PULLUP
 
-pin_value = r.arduino.pins[4].digital_state
+pin_value = robot.arduino.pins[4].digital_state
 ```
 
 ### `GPIOPinMode.DIGITAL_OUTPUT`
 
 In this mode, we can set binary values of `0V` or `5V` to the pin.
 
 ``` python
-r.arduino.pins[4].mode = GPIOPinMode.DIGITAL_OUTPUT
-r.arduino.pins[6].mode = GPIOPinMode.DIGITAL_OUTPUT
+robot.arduino.pins[4].mode = GPIOPinMode.DIGITAL_OUTPUT
+robot.arduino.pins[6].mode = GPIOPinMode.DIGITAL_OUTPUT
 
-r.arduino.pins[4].digital_state = True
-r.arduino.pins[6].digital_state = False
+robot.arduino.pins[4].digital_state = True
+robot.arduino.pins[6].digital_state = False
 ```
 
 ### `GPIOPinMode.ANALOGUE_INPUT`
@@ -96,9 +96,9 @@ cannot be used.
 ``` python
 from sbot import AnaloguePin
 
-r.arduino.pins[AnaloguePin.A0].mode = GPIOPinMode.ANALOGUE_INPUT
+robot.arduino.pins[AnaloguePin.A0].mode = GPIOPinMode.ANALOGUE_INPUT
 
-pin_value = r.arduino.pins[AnaloguePin.A0].analogue_value
+pin_value = robot.arduino.pins[AnaloguePin.A0].analogue_value
 ```
 
 !!! tip
@@ -112,7 +112,7 @@ You can also measure distance using an ultrasound sensor from the arduino.
 # Trigger pin: 4
 # Echo pin: 5
 
-distance_metres = r.arduino.ultrasound_measure(4, 5)
+distance_metres = robot.arduino.ultrasound_measure(4, 5)
 ```
 
 !!! warning

docs/programming/game-state.md

@@ -15,7 +15,7 @@ Your robot can be in 1 of 2 modes: `DEVELOPMENT` and `COMPETITION`. By
 default, your robot will be in `DEVELOPMENT` mode:
 
 ``` python
-r.is_competition
+robot.is_competition
 >> False
 ```
 
@@ -29,9 +29,9 @@ zone. The number of zones depends on the game. Each zone is given a
 number, which you can access with the `zone` property:
 
 ``` python
-r.zone
+robot.zone
 >> 1
 ```
 
 During a competition match, a USB drive will be used to tell your robot
-which corner it's in. By default during development, this is `0`.
+which corner it's in. By default during development, this is `0`.

docs/programming/index.md

@@ -14,14 +14,17 @@ kit:
 ``` python
 from sbot import *
 
-r = Robot()
+robot = Robot()
 ```
 
 Once this has been done, this `Robot` object can be used to control the
 robot's functions.
 
 The remainder of the tutorials pages will assume your `Robot` object is
-defined as `r`.
+defined as `robot`.
+
+!!! note
+    In Python, variables are case-sensitive. `robot` is an instance of `Robot`.
 
 ## Running your code
 
@@ -47,11 +50,11 @@ what it didn't do, and any errors it raised. The file is saved to log.txt in the
 If you want to do things before the start button press, such as setting up servos or motors, you can pass `wait_start` to the `Robot` constructor. You will then need to wait for the start button manually.
 
 ```python
-r = Robot(wait_start=False)
+robot = Robot(wait_start=False)
 
 # Do your setup here
 
-r.wait_start()
+robot.wait_start()
 ```
 
 ## Debug mode
@@ -62,7 +65,8 @@ In "Debug Mode", your robot will print more information about what it is doing.
 
 ```python
 from sbot import Robot
-r = Robot(debug=True)
+
+robot = Robot(debug=True)
 ```
 
 !!! info

docs/programming/motor-board.md

@@ -9,19 +9,19 @@ If there is exactly one motor board attached to your robot, it can be
 accessed using the `motor_board` property of the `Robot` object.
 
 ``` python
-my_motor_board = r.motor_board
+my_motor_board = robot.motor_board
 ```
 
 !!! warning
-    If there is more than one motor board on your kit, you *must* use the `motor_boards` property. `r.motor_board` *will cause an error*. This is because the kit doesn't know which motor board you want to access.
+    If there is more than one motor board on your kit, you *must* use the `motor_boards` property. `robot.motor_board` *will cause an error*. This is because the kit doesn't know which motor board you want to access.
 
 Motor boards attached to your robot can be accessed under the
 `motor_boards` property of the `Robot`. The boards are indexed by their
 serial number, which is written on the board.
 
 ``` python
-my_motor_board = r.motor_boards["SRO-AAD-GBH"]
-my_other_motor_board = r.motor_boards["SR08U6"]
+my_motor_board = robot.motor_boards["SRO-AAD-GBH"]
+my_other_motor_board = robot.motor_boards["SR08U6"]
 ```
 
 ## Controlling the Motor Board

docs/programming/power-board.md

@@ -4,7 +4,7 @@ The power board can be accessed using the `power_board` property of
 the `Robot` object.
 
 ```python
-my_power_board = r.power_board
+my_power_board = robot.power_board
 ```
 
 ## Power outputs
@@ -21,8 +21,8 @@ The power board's six outputs can be turned on and off using the
     pressed.
 
 ```python
-r.power_board.outputs.power_off()
-r.power_board.outputs.power_on()
+robot.power_board.outputs.power_off()
+robot.power_board.outputs.power_on()
 ```
 
 You can also get information about and control each output in the group.
@@ -31,12 +31,12 @@ An output is indexed using the appropriate `PowerOutputPosition`.
 ```python
 from sbot import PowerOutputPosition
 
-r.power_board.outputs[PowerOutputPosition.H0].is_enabled = True
-r.power_board.outputs[PowerOutputPosition.L3].is_enabled = False
+robot.power_board.outputs[PowerOutputPosition.H0].is_enabled = True
+robot.power_board.outputs[PowerOutputPosition.L3].is_enabled = False
 
-boolean_value = r.power_board.outputs[PowerOutputPosition.L2].is_enabled
+boolean_value = robot.power_board.outputs[PowerOutputPosition.L2].is_enabled
 
-current_amps = r.power_board.outputs[PowerOutputPosition.H1].current
+current_amps = robot.power_board.outputs[PowerOutputPosition.H1].current
 ```
 
 !!! warning
@@ -51,8 +51,8 @@ The power board has some sensors that can monitor the status of your battery.
 This can be useful for checking the charge status of your battery.
 
 ```python
-battery_voltage = r.power_board.battery_sensor.voltage
-battery_current_amps = r.power_board.battery_sensor.current
+battery_voltage = robot.power_board.battery_sensor.voltage
+battery_current_amps = robot.power_board.battery_sensor.current
 ```
 
 ## Buzzing 🐝
@@ -80,10 +80,10 @@ The `Note` enum provides notes in [scientific pitch notation](https://en.wikiped
 from sbot import Note
 
 # Buzz for half a second in D6.
-r.power_board.piezo.buzz(0.5, Note.D6)
+robot.power_board.piezo.buzz(0.5, Note.D6)
 
 # Buzz for 2 seconds at 400Hz
-r.power_board.piezo.buzz(2, 400)
+robot.power_board.piezo.buzz(2, 400)
 ```
 
 ## Start Button
@@ -92,7 +92,7 @@ You can manually wait for the start button to be pressed, not only at
 the start.
 
 ```python
-r.wait_start()
+robot.wait_start()
 ```
 
 This may be useful for debugging, but be sure to remove it in the

docs/programming/servo-board.md

@@ -9,7 +9,7 @@ The servo board can be accessed using the `servo_board` property of
 the `Robot` object.
 
 ```python
-my_servo_board = r.servo_board
+my_servo_board = robot.servo_board
 ```
 
 This board object has an array containing the servos connected to it,
@@ -25,16 +25,16 @@ The position of servos can range from `-1` to `1` inclusive:
 
 ```python
 # set servo 1's position to 0.2
-r.servo_board.servos[1].position = 0.2
+robot.servo_board.servos[1].position = 0.2
 
 # Set servo 2's position to -0.55
-r.servo_board.servos[2].position = -0.55
+robot.servo_board.servos[2].position = -0.55
 ```
 
 You can read the last value a servo was set to using similar code:
 
 ```python
-last_position = r.servo_board.servos[11].position
+last_position = robot.servo_board.servos[11].position
 ```
 
 !!! warning

docs/programming/vision/index.md

@@ -11,11 +11,11 @@ the marker relative to the webcam. Using this data, it is possible to determine
 
 ## Searching for markers
 
-Assuming you have a webcam connected, you can use `r.camera.see()` to take a picture. The software will process the picture
+Assuming you have a webcam connected, you can use `robot.camera.see()` to take a picture. The software will process the picture
 and returns a list of the markers it sees.
 
 ```python
-markers = r.camera.see()
+markers = robot.camera.see()
 ```
 
 !!! tip
@@ -30,7 +30,7 @@ corner of the marker. The ID of every marker is also written next to it.
 Snapshots are saved to your USB drive, and can be viewed on another computer.
 
 ```python
-r.camera.save("snapshot.jpg")
+robot.camera.save("snapshot.jpg")
 ```
 
 ![An annotated arena with Fiducial Markers.](../../assets/img/api/vision/arena_marker_annotated.jpg){ width="50%" }
@@ -44,7 +44,7 @@ The marker objects in the list expose data that may be useful to your robot.
 Every marker has a numeric identifier that can be used to determine what object it represents.
 
 ```python
-markers = r.camera.see()
+markers = robot.camera.see()
 
 for m in markers:
     print(m.id)
@@ -57,7 +57,7 @@ Each marker has a position in 3D space, relative to your webcam.
 You can access the position using `m.distance`, `m.cartesian` and `m.spherical`.
 
 ```python
-markers = r.camera.see()
+markers = robot.camera.see()
 
 for m in markers:
     print(m.distance)  # Distance to the marker from the webcam, in metres
@@ -82,7 +82,7 @@ You can access the size of a marker using `m.size`.
 Check the rules to find out how big the different marker types are.
 
 ```python
-markers = r.camera.see()
+markers = robot.camera.see()
 
 for m in markers:
     print(m.size)
@@ -98,7 +98,7 @@ marker. Pixels are counted from the origin of the image, which
 conventionally is in the top left corner of the image.
 
 ```python
-markers = r.camera.see()
+markers = robot.camera.see()
 
 for m in markers:
     print(m.pixel_corners)  # Pixel positions of the marker corners within the image.

docs/programming/vision/orientation.md

@@ -11,12 +11,12 @@ Orientation represents the rotation of a marker around the x, y, and z axes. The
 Rotations are applied in order of z, y, x.
 
 ```python
-markers = r.camera.see()
+markers = robot.camera.see()
 
-for m in markers:
-   print(m.orientation.rot_x)  # Angle of rotation about x axis.
-   print(m.orientation.rot_y)  # Angle of rotation about y axis.
-   print(m.orientation.rot_z)  # Angle of rotation about z axis.
+for marker in markers:
+   print(marker.orientation.rot_x)  # Angle of rotation about x axis.
+   print(marker.orientation.rot_y)  # Angle of rotation about y axis.
+   print(marker.orientation.rot_z)  # Angle of rotation about z axis.
 ```
 
 !!! note

docs/programming/vision/position.md

@@ -19,7 +19,7 @@ The value of each coordinate indicates the distance travelled along the axis to
 The camera is located at the origin, where the coordinates are ``(0, 0, 0)``.
 
 ```python
-markers = r.camera.see()
+markers = robot.camera.see()
 
 for m in markers:
     print(m.cartesian.x)  # Displacement from the origin in millimetres, along x axis.
@@ -44,7 +44,7 @@ three values to specify a specific point in space.
 The camera is located at the origin, where the coordinates are `(0, 0, 0)`.
 
 ```python
-markers = r.camera.see()
+markers = robot.camera.see()
 
 for m in markers:
   print(m.spherical.distance)  # Distance from the origin in millimetres