reformating/updating to match java examples

fletch3555 · fletch3555 · commit f68a8e408602 · 2023-12-17T06:38:03.000-05:00
diff --git a/arcade-drive-xbox-controller/robot.py b/arcade-drive-xbox-controller/robot.py
@@ -18,20 +18,15 @@ class MyRobot(wpilib.TimedRobot):
     def robotInit(self):
         """Robot initialization function"""
 
-        # create motor controller objects
-        left = wpilib.PWMSparkMax(0)
-        right = wpilib.PWMSparkMax(1)
-
-        # object that handles basic drive operations
-        self.robotDrive = wpilib.drive.DifferentialDrive(left, right)
-
-        # xbox controller 0 on the driver station
+        leftMotor = wpilib.PWMSparkMax(0)
+        rightMotor = wpilib.PWMSparkMax(1)
+        self.robotDrive = wpilib.drive.DifferentialDrive(leftMotor, rightMotor)
         self.driverController = wpilib.XboxController(0)
 
         # We need to invert one side of the drivetrain so that positive voltages
         # result in both sides moving forward. Depending on how your robot's
         # gearbox is constructed, you might have to invert the left side instead.
-        right.setInverted(True)
+        rightMotor.setInverted(True)
 
     def teleopPeriodic(self):
         # Drive with split arcade style
diff --git a/arcade-drive/robot.py b/arcade-drive/robot.py
@@ -18,26 +18,21 @@ class MyRobot(wpilib.TimedRobot):
     def robotInit(self):
         """Robot initialization function"""
 
-        # create motor controller objects
-        left = wpilib.PWMSparkMax(0)
-        right = wpilib.PWMSparkMax(1)
-
-        # object that handles basic drive operations
-        self.robotDrive = wpilib.drive.DifferentialDrive(left, right)
-
-        # joystick 0 on the driver station
+        leftMotor = wpilib.PWMSparkMax(0)
+        rightMotor = wpilib.PWMSparkMax(1)
+        self.robotDrive = wpilib.drive.DifferentialDrive(leftMotor, rightMotor)
         self.stick = wpilib.Joystick(0)
 
         # We need to invert one side of the drivetrain so that positive voltages
         # result in both sides moving forward. Depending on how your robot's
         # gearbox is constructed, you might have to invert the left side instead.
-        right.setInverted(True)
+        rightMotor.setInverted(True)
 
     def teleopPeriodic(self):
-        # Drive with split arcade style
-        # That means that the Y axis of the left stick moves forward
-        # and backward, and the X of the right stick turns left and right.
-        self.robotDrive.arcadeDrive(-self.stick.getY(), -self.stick.getX())
+        # Drive with arcade drive.
+        # That means that the Y axis drives forward
+        # and backward, and the X turns left and right.
+        self.robotDrive.arcadeDrive(self.stick.getY(), self.stick.getX())
 
 
 if __name__ == "__main__":
diff --git a/canpdp/robot.py b/canpdp/robot.py
@@ -6,7 +6,6 @@
 #
 
 import wpilib
-import wpilib.drive
 
 
 class MyRobot(wpilib.TimedRobot):
diff --git a/gyro/robot.py b/gyro/robot.py
@@ -6,66 +6,49 @@
 #
 
 import wpilib
-from wpilib.drive import DifferentialDrive
+import wpilib.drive
 
 
 class MyRobot(wpilib.TimedRobot):
-    """This is a demo program showing how to use Gyro control with the
-    DifferentialDrive class."""
+    """
+    This is a sample program to demonstrate how to use a gyro sensor to make a robot drive straight.
+    This program uses a joystick to drive forwards and backwards while the gyro is used for direction
+    keeping.
+    """
 
-    def robotInit(self):
-        """Robot initialization function"""
-        gyroChannel = 0  # analog input
-
-        self.joystickChannel = 0  # usb number in DriverStation
+    ANGLE_SETPOINT = 0.0
+    P = 0.005  # propotional turning constant
 
-        # channels for motors
-        self.leftMotorChannel = 1
-        self.rightMotorChannel = 0
-        self.leftRearMotorChannel = 3
-        self.rightRearMotorChannel = 2
+    # gyro calibration constant, may need to be adjusted;
+    # gyro value of 360 is set to correspond to one full revolution
+    VOLTS_PER_DEGREE_PER_SECOND = 0.0128
 
-        self.angleSetpoint = 0.0
-        self.pGain = 1  # propotional turning constant
+    LEFT_MOTOR_PORT = 0
+    RIGHT_MOTOR_PORT = 1
+    GYRO_PORT = 0
+    JOYSTICK_PORT = 0
 
-        # gyro calibration constant, may need to be adjusted
-        # gyro value of 360 is set to correspond to one full revolution
-        self.voltsPerDegreePerSecond = 0.0128
+    def robotInit(self):
+        """Robot initialization function"""
 
-        self.left = wpilib.MotorControllerGroup(
-            wpilib.Talon(self.leftMotorChannel), wpilib.Talon(self.leftRearMotorChannel)
-        )
-        self.right = wpilib.MotorControllerGroup(
-            wpilib.Talon(self.rightMotorChannel),
-            wpilib.Talon(self.rightRearMotorChannel),
-        )
-        self.myRobot = DifferentialDrive(self.left, self.right)
+        self.leftDrive = wpilib.PWMSparkMax(self.LEFT_MOTOR_PORT)
+        self.rightDrive = wpilib.PWMSparkMax(self.RIGHT_MOTOR_PORT)
+        self.myRobot = wpilib.drive.DifferentialDrive(self.leftDrive, self.rightDrive)
+        self.gyro = wpilib.AnalogGyro(self.GYRO_PORT)
+        self.joystick = wpilib.Joystick(self.JOYSTICK_PORT)
 
-        self.gyro = wpilib.AnalogGyro(gyroChannel)
-        self.joystick = wpilib.Joystick(self.joystickChannel)
+        self.gyro.setSensitivity(self.VOLTS_PER_DEGREE_PER_SECOND)
 
-    def teleopInit(self):
-        """
-        Runs at the beginning of the teleop period
-        """
-        self.gyro.setSensitivity(
-            self.voltsPerDegreePerSecond
-        )  # calibrates gyro values to equal degrees
+        # We need to invert one side of the drivetrain so that positive voltages
+        # result in both sides moving forward. Depending on how your robot's
+        # gearbox is constructed, you might have to invert the left side instead.
+        self.rightDrive.setInverted(True)
 
     def teleopPeriodic(self):
-        """
-        Sets the gyro sensitivity and drives the robot when the joystick is pushed. The
-        motor speed is set from the joystick while the RobotDrive turning value is assigned
-        from the error between the setpoint and the gyro angle.
-        """
-
-        turningValue = (self.angleSetpoint - self.gyro.getAngle()) * self.pGain
-        if self.joystick.getY() <= 0:
-            # forwards
-            self.myRobot.arcadeDrive(self.joystick.getY(), turningValue)
-        elif self.joystick.getY() > 0:
-            # backwards
-            self.myRobot.arcadeDrive(self.joystick.getY(), -turningValue)
+        # The motor speed is set from the joystick while the DifferentialDrive turning value is assigned
+        # from the error between the setpoint and the gyro angle.
+        turningValue = (self.ANGLE_SETPOINT - self.gyro.getAngle()) * self.P
+        self.myRobot.arcadeDrive(-self.joystick.getY(), -turningValue)
 
 
 if __name__ == "__main__":
diff --git a/motor-control/robot.py b/motor-control/robot.py
@@ -7,37 +7,42 @@
 
 import wpilib
 
+import math
+
 
 class MyRobot(wpilib.TimedRobot):
     """
-    This sample program shows how to control a motor using a joystick. In the
-    operator control part of the program, the joystick is read and the value
-    is written to the motor.
-
-    Joystick analog values range from -1 to 1 and speed controller inputs also
-    range from -1 to 1 making it easy to work together. The program also delays
-    a short time in the loop to allow other threads to run. This is generally
-    a good idea, especially since the joystick values are only transmitted
-    from the Driver Station once every 20ms.
+    This sample program shows how to control a motor using a joystick. In the operator control part
+    of the program, the joystick is read and the value is written to the motor.
+
+    <p>Joystick analog values range from -1 to 1 and motor controller inputs also range from -1 to 1
+    making it easy to work together.
+
+    <p>In addition, the encoder value of an encoder connected to ports 0 and 1 is consistently sent
+    to the Dashboard.
     """
 
-    #: update every 0.005 seconds/5 milliseconds (200Hz)
-    kUpdatePeriod = 0.005
+    MOTOR_PORT = 0
+    JOYSTICK_PORT = 0
+    ENCODER_PORT_A = 0
+    ENCODER_PORT_B = 1
 
     def robotInit(self):
         """Robot initialization function"""
 
-        self.motor = wpilib.Talon(0)  # initialize the motor as a Talon on channel 0
-        self.stick = wpilib.Joystick(0)  # initialize the joystick on port 0
+        self.motor = wpilib.PWMSparkMax(self.MOTOR_PORT)
+        self.joystick = wpilib.Joystick(self.JOYSTICK_PORT)
+        self.encoder = wpilib.Encoder(self.ENCODER_PORT_A, self.ENCODER_PORT_B)
+        # Use SetDistancePerPulse to set the multiplier for GetDistance
+        # This is set up assuming a 6 inch wheel with a 360 CPR encoder.
+        self.encoder.setDistancePerPulse((math.pi * 6) / 360.0)
 
-    def teleopPeriodic(self):
-        """Runs the motor from a joystick."""
-
-        # Set the motor's output.
-        # This takes a number from -1 (100% speed in reverse) to
-        # +1 (100% speed going forward)
+    def robotPeriodic(self):
+        """The RobotPeriodic function is called every control packet no matter the robot mode."""
+        wpilib.SmartDashboard.putNumber("Encoder", self.encoder.getDistance())
 
-        self.motor.set(self.stick.getY())
+    def teleopPeriodic(self):
+        self.motor.set(self.joystick.getY())
 
 
 if __name__ == "__main__":
diff --git a/tank-drive-xbox-controller/robot.py b/tank-drive-xbox-controller/robot.py
@@ -6,7 +6,7 @@
 #
 
 import wpilib
-from wpilib.drive import DifferentialDrive
+import wpilib.drive
 
 
 class MyRobot(wpilib.TimedRobot):
@@ -18,19 +18,15 @@ class MyRobot(wpilib.TimedRobot):
     def robotInit(self):
         """Robot initialization function"""
 
-        # object that handles basic drive operations
-        left = wpilib.PWMSparkMax(0)
-        right = wpilib.PWMSparkMax(1)
-
-        self.robotDrive = DifferentialDrive(left, right)
-
-        # xbox controller 0 on the driver station
+        leftMotor = wpilib.PWMSparkMax(0)
+        rightMotor = wpilib.PWMSparkMax(1)
+        self.robotDrive = wpilib.drive.DifferentialDrive(leftMotor, rightMotor)
         self.driverController = wpilib.XboxController(0)
 
         # We need to invert one side of the drivetrain so that positive voltages
         # result in both sides moving forward. Depending on how your robot's
         # gearbox is constructed, you might have to invert the left side instead.
-        right.setInverted(True)
+        rightMotor.setInverted(True)
 
     def teleopPeriodic(self):
         # Drive with tank drive.
diff --git a/tank-drive/robot.py b/tank-drive/robot.py
@@ -6,7 +6,7 @@
 #
 
 import wpilib
-from wpilib.drive import DifferentialDrive
+import wpilib.drive
 
 
 class MyRobot(wpilib.TimedRobot):
@@ -18,23 +18,18 @@ class MyRobot(wpilib.TimedRobot):
     def robotInit(self):
         """Robot initialization function"""
 
-        # object that handles basic drive operations
-        left = wpilib.PWMSparkMax(0)
-        right = wpilib.PWMSparkMax(1)
-
-        self.robotDrive = DifferentialDrive(left, right)
-
-        # joysticks 1 & 2 on the driver station
+        leftMotor = wpilib.PWMSparkMax(0)
+        rightMotor = wpilib.PWMSparkMax(1)
+        self.robotDrive = wpilib.drive.DifferentialDrive(leftMotor, rightMotor)
         self.leftStick = wpilib.Joystick(0)
         self.rightStick = wpilib.Joystick(1)
 
         # We need to invert one side of the drivetrain so that positive voltages
         # result in both sides moving forward. Depending on how your robot's
         # gearbox is constructed, you might have to invert the left side instead.
-        right.setInverted(True)
+        rightMotor.setInverted(True)
 
     def teleopPeriodic(self):
-        """Drive with tank style"""
         self.robotDrive.tankDrive(-self.leftStick.getY(), -self.rightStick.getY())
 
 

Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,6 @@`
`6`	`6`	`#`
`7`	`7`
`8`	`8`	`import wpilib`
`9`		`-import wpilib.drive`
`10`	`9`
`11`	`10`
`12`	`11`	`class MyRobot(wpilib.TimedRobot):`