Merge pull request #91 from fletch3555/low-hanging-fruit

low hanging fruit

Author: virtuald

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

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__":

canpdp/robot.py

@@ -6,7 +6,6 @@
 #
 
 import wpilib
-import wpilib.drive
 
 
 class MyRobot(wpilib.TimedRobot):

digital-communication/robot.py

@@ -0,0 +1,52 @@
+#!/usr/bin/env python3
+#
+# Copyright (c) FIRST and other WPILib contributors.
+# Open Source Software; you can modify and/or share it under the terms of
+# the WPILib BSD license file in the root directory of this project.
+#
+
+import wpilib
+
+
+class MyRobot(wpilib.TimedRobot):
+    """
+    This is a sample program demonstrating how to communicate to a light controller from the robot
+    code using the roboRIO's DIO ports.
+    """
+
+    # define ports for digitalcommunication with light controller
+    kAlliancePort = 0
+    kEnabledPort = 1
+    kAutonomousPort = 2
+    kAlertPort = 3
+
+    def robotInit(self):
+        """Robot initialization function"""
+
+        self.allianceOutput = wpilib.DigitalOutput(self.kAlliancePort)
+        self.enabledOutput = wpilib.DigitalOutput(self.kEnabledPort)
+        self.autonomousOutput = wpilib.DigitalOutput(self.kAutonomousPort)
+        self.alertOutput = wpilib.DigitalOutput(self.kAlertPort)
+
+    def robotPeriodic(self):
+        setAlliance = False
+        alliance = wpilib.DriverStation.getAlliance()
+        if alliance:
+            setAlliance = alliance == wpilib.DriverStation.Alliance.kRed
+
+        # pull alliance port high if on red alliance, pull low if on blue alliance
+        self.allianceOutput.set(setAlliance)
+
+        # pull enabled port high if enabled, low if disabled
+        self.enabledOutput.set(wpilib.DriverStation.isEnabled())
+
+        # pull auto port high if in autonomous, low if in teleop (or disabled)
+        self.autonomousOutput.set(wpilib.DriverStation.isAutonomous())
+
+        # pull alert port high if match time remaining is between 30 and 25 seconds
+        matchTime = wpilib.DriverStation.getMatchTime()
+        self.alertOutput.set(30 >= matchTime >= 25)
+
+
+if __name__ == "__main__":
+    wpilib.run(MyRobot)

dutycycle-encoder/robot.py

@@ -0,0 +1,39 @@
+#!/usr/bin/env python3
+#
+# Copyright (c) FIRST and other WPILib contributors.
+# Open Source Software; you can modify and/or share it under the terms of
+# the WPILib BSD license file in the root directory of this project.
+#
+
+import wpilib
+
+
+class MyRobot(wpilib.TimedRobot):
+    def robotInit(self):
+        """Robot initialization function"""
+
+        self.dutyCycleEncoder = wpilib.DutyCycleEncoder(0)
+
+        self.dutyCycleEncoder.setDistancePerRotation(0.5)
+
+    def robotPeriodic(self):
+        # Connected can be checked, and uses the frequency of the encoder
+        connected = self.dutyCycleEncoder.isConnected()
+
+        # Duty Cycle Frequency in Hz
+        frequency = self.dutyCycleEncoder.getFrequency()
+
+        # Output of encoder
+        output = self.dutyCycleEncoder.get()
+
+        # Output scaled by DistancePerPulse
+        distance = self.dutyCycleEncoder.getDistance()
+
+        wpilib.SmartDashboard.putBoolean("Connected", connected)
+        wpilib.SmartDashboard.putNumber("Frequency", frequency)
+        wpilib.SmartDashboard.putNumber("Output", output)
+        wpilib.SmartDashboard.putNumber("Distance", distance)
+
+
+if __name__ == "__main__":
+    wpilib.run(MyRobot)

dutycycle-input/robot.py

@@ -0,0 +1,30 @@
+#!/usr/bin/env python3
+#
+# Copyright (c) FIRST and other WPILib contributors.
+# Open Source Software; you can modify and/or share it under the terms of
+# the WPILib BSD license file in the root directory of this project.
+#
+
+import wpilib
+
+
+class MyRobot(wpilib.TimedRobot):
+    def robotInit(self):
+        """Robot initialization function"""
+
+        self.dutyCycle = wpilib.DutyCycle(wpilib.DigitalInput(0))
+
+    def robotPeriodic(self):
+        # Duty Cycle Frequency in Hz
+        frequency = self.dutyCycle.getFrequency()
+
+        # Output of duty cycle, ranging from 0 to 1
+        # 1 is fully on, 0 is fully off
+        output = self.dutyCycle.getOutput()
+
+        wpilib.SmartDashboard.putNumber("Frequency", frequency)
+        wpilib.SmartDashboard.putNumber("Duty Cycle", output)
+
+
+if __name__ == "__main__":
+    wpilib.run(MyRobot)

encoder/robot.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python3
+#
+# Copyright (c) FIRST and other WPILib contributors.
+# Open Source Software; you can modify and/or share it under the terms of
+# the WPILib BSD license file in the root directory of this project.
+#
+
+import wpilib
+
+import math
+
+
+class MyRobot(wpilib.TimedRobot):
+    """
+    Sample program displaying the value of a quadrature encoder on the SmartDashboard. Quadrature
+    Encoders are digital sensors which can detect the amount the encoder has rotated since starting
+    as well as the direction in which the encoder shaft is rotating. However, encoders can not tell
+    you the absolute position of the encoder shaft (ie, it considers where it starts to be the zero
+    position, no matter where it starts), and so can only tell you how much the encoder has rotated
+    since starting. Depending on the precision of an encoder, it will have fewer or greater ticks per
+    revolution; the number of ticks per revolution will affect the conversion between ticks and
+    distance, as specified by DistancePerPulse. One of the most common uses of encoders is in the
+    drivetrain, so that the distance that the robot drives can be precisely controlled during the
+    autonomous mode.
+    """
+
+    def robotInit(self):
+        """Robot initialization function"""
+
+        self.encoder = wpilib.Encoder(1, 2, False, wpilib.Encoder.EncodingType.k4X)
+
+        # Defines the number of samples to average when determining the rate.
+        # On a quadrature encoder, values range from 1-255;
+        # larger values result in smoother but potentially
+        # less accurate rates than lower values.
+        self.encoder.setSamplesToAverage(5)
+
+        # Defines how far the mechanism attached to the encoder moves per pulse. In
+        # this case, we assume that a 360 count encoder is directly
+        # attached to a 3 inch diameter (1.5inch radius) wheel,
+        # and that we want to measure distance in inches.
+        self.encoder.setDistancePerPulse(1.0 / 360.0 * 2.0 * math.pi * 1.5)
+
+        # Defines the lowest rate at which the encoder will
+        # not be considered stopped, for the purposes of
+        # the GetStopped() method. Units are in distance / second,
+        # where distance refers to the units of distance
+        # that you are using, in this case inches.
+        self.encoder.setMinRate(1.0)
+
+    def teleopPeriodic(self):
+        wpilib.SmartDashboard.putNumber("Encoder Distance", self.encoder.getDistance())
+        wpilib.SmartDashboard.putNumber("Encoder Rate", self.encoder.getRate())
+
+
+if __name__ == "__main__":
+    wpilib.run(MyRobot)

flywheel-bangbang-controller/physics.py

@@ -0,0 +1,58 @@
+#
+# Copyright (c) FIRST and other WPILib contributors.
+# Open Source Software; you can modify and/or share it under the terms of
+# the WPILib BSD license file in the root directory of this project.
+#
+
+import wpilib.simulation
+from wpimath.system.plant import DCMotor
+
+from pyfrc.physics.core import PhysicsInterface
+
+import typing
+
+if typing.TYPE_CHECKING:
+    from robot import MyRobot
+
+
+class PhysicsEngine:
+    """
+    Simulates a flywheel
+    """
+
+    def __init__(self, physics_controller: PhysicsInterface, robot: "MyRobot"):
+        """
+        :param physics_controller: `pyfrc.physics.core.Physics` object
+                                   to communicate simulation effects to
+        """
+
+        self.physics_controller = physics_controller
+
+        # Motors
+        self.flywheelMotor = wpilib.simulation.PWMSim(robot.flywheelMotor.getChannel())
+
+        # Sensors
+        self.encoder = wpilib.simulation.EncoderSim(robot.encoder)
+
+        # Flywheel
+        self.flywheel = wpilib.simulation.FlywheelSim(
+            DCMotor.NEO(1), robot.kFlywheelGearing, robot.kFlywheelMomentOfInertia
+        )
+
+    def update_sim(self, now: float, tm_diff: float) -> None:
+        """
+        Called when the simulation parameters for the program need to be
+        updated.
+
+        :param now: The current time as a float
+        :param tm_diff: The amount of time that has passed since the last
+                        time that this function was called
+        """
+
+        # To update our simulation, we set motor voltage inputs, update the
+        # simulation, and write the simulated velocities to our simulated encoder
+        self.flywheel.setInputVoltage(
+            self.flywheelMotor.getSpeed() * wpilib.RobotController.getInputVoltage()
+        )
+        self.flywheel.update(0.02)
+        self.encoder.setRate(self.flywheel.getAngularVelocity())

flywheel-bangbang-controller/robot.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python3
+#
+# Copyright (c) FIRST and other WPILib contributors.
+# Open Source Software; you can modify and/or share it under the terms of
+# the WPILib BSD license file in the root directory of this project.
+#
+
+import wpilib
+import wpilib.simulation
+import wpimath.controller
+import wpimath.units
+
+import math
+
+
+class MyRobot(wpilib.TimedRobot):
+    """
+    This is a sample program to demonstrate the use of a BangBangController with a flywheel to
+    control RPM.
+    """
+
+    kMotorPort = 0
+    kEncoderAChannel = 0
+    kEncoderBChannel = 1
+
+    # Max setpoint for joystick control in RPM
+    kMaxSetpointValue = 6000.0
+
+    # Gains are for example purposes only - must be determined for your own robot!
+    kFlywheelKs = 0.0001  # V
+    kFlywheelKv = 0.000195  # V/RPM
+    kFlywheelKa = 0.0003  # V/(RPM/s)
+
+    # Reduction between motors and encoder, as output over input. If the flywheel
+    # spins slower than the motors, this number should be greater than one.
+    kFlywheelGearing = 1.0
+
+    # 1/2 MR²
+    kFlywheelMomentOfInertia = (
+        0.5
+        * wpimath.units.lbsToKilograms(1.5)
+        * math.pow(wpimath.units.inchesToMeters(4), 2)
+    )
+
+    def robotInit(self):
+        """Robot initialization function"""
+
+        self.feedforward = wpimath.controller.SimpleMotorFeedforwardMeters(
+            self.kFlywheelKs, self.kFlywheelKv, self.kFlywheelKa
+        )
+
+        # Joystick to control setpoint
+        self.joystick = wpilib.Joystick(0)
+
+        self.flywheelMotor = wpilib.PWMSparkMax(self.kMotorPort)
+        self.encoder = wpilib.Encoder(self.kEncoderAChannel, self.kEncoderBChannel)
+
+        self.bangBangControler = wpimath.controller.BangBangController()
+
+        # Add bang-bang controler to SmartDashboard and networktables.
+        wpilib.SmartDashboard.putData(self.bangBangControler)
+
+    def teleopPeriodic(self):
+        """Controls flywheel to a set speed (RPM) controlled by a joystick."""
+
+        # Scale setpoint value between 0 and maxSetpointValue
+        setpoint = max(
+            0.0,
+            self.joystick.getRawAxis(0)
+            * wpimath.units.rotationsPerMinuteToRadiansPerSecond(
+                self.kMaxSetpointValue
+            ),
+        )
+
+        # Set setpoint and measurement of the bang-bang controller
+        bangOutput = (
+            self.bangBangControler.calculate(self.encoder.getRate(), setpoint) * 12.0
+        )
+
+        # Controls a motor with the output of the BangBang controller and a
+        # feedforward. The feedforward is reduced slightly to avoid overspeeding
+        # the shooter.
+        self.flywheelMotor.setVoltage(
+            bangOutput + 0.9 * self.feedforward.calculate(setpoint)
+        )
+
+
+if __name__ == "__main__":
+    wpilib.run(MyRobot)