Merge branch 'NextFTC:develop' into DriveUtil

Author: 28shettr

gradle/libs.versions.toml

@@ -7,7 +7,7 @@ kotest = "5.9.1"
 sloth = "0.2.4"
 spotless = "8.1.0"
 ejml = "0.41"
-ivy = "1.0.0"
+ivy = "1.0.1"
 
 [libraries]
 dokka-mathjax-plugin = { module = "org.jetbrains.dokka:mathjax-plugin" }
@@ -23,7 +23,7 @@ ftc-hardware = { group = "org.firstinspires.ftc", name = "Hardware", version.ref
 ftc-common = { group = "org.firstinspires.ftc", name = "FtcCommon", version.ref = "ftc" }
 sloth = { module = "dev.frozenmilk.sinister:Sloth", version.ref = "sloth" }
 kotlin-reflect = { module = "org.jetbrains.kotlin:kotlin-reflect", version.ref = "kotlin" }
-ivy = { module = "com.pedropathing:ivy", version.ref = "ivy" }
+ivy = { module = "com.pedropathing.ivy:core", version.ref = "ivy" }
 
 [bundles]
 kotest = ["kotest-runner", "kotest-assertations", "kotest-property", "kotest-data-driven"]

hardware/src/main/kotlin/dev/nextftc/hardware/actuators/NextCRServo.kt

@@ -44,12 +44,21 @@ open class NextCRServo @JvmOverloads constructor(
    * @param port The servo port (in the range [0, 5]).
    * @param cacheTolerance Tolerance used by the [Caching] delegate for power updates; defaults to 0.01.
    */
-  @JvmOverloads constructor(module: NextLynxModule, port: Int, cacheTolerance: Double = 0.01) : this(
+  @JvmOverloads constructor(
+    module: NextLynxModule,
+    port: Int,
+    cacheTolerance: Double = 0.01,
+  ) : this(
     { CRServoImplEx(module.servoController, port, ServoConfigurationType.getStandardServoType()) },
     cacheTolerance,
-  )
+  ) {
+    require(port in 0..3) { "Expected port in range [0, 3], got $port" }
+  }
 
-  @JvmOverloads constructor(name: String, cacheTolerance: Double = 0.01) : this(
+  @JvmOverloads constructor(
+    name: String,
+    cacheTolerance: Double = 0.01,
+  ) : this(
     { RobotController.hardwareMap[name] as CRServoImplEx },
     cacheTolerance,
   )

hardware/src/main/kotlin/dev/nextftc/hardware/actuators/NextFeedbackCRServo.kt

@@ -8,7 +8,6 @@
 
 package dev.nextftc.hardware.actuators
 
-import com.qualcomm.robotcore.hardware.AnalogInput
 import com.qualcomm.robotcore.hardware.CRServoImplEx
 import com.qualcomm.robotcore.hardware.configuration.typecontainers.ServoConfigurationType
 import dev.nextftc.hardware.RobotController
@@ -29,45 +28,48 @@ import dev.nextftc.units.radians
  *
  * @param initializer A function returning the backing [CRServoImplEx]. It will
  * be invoked lazily the first time the servo is accessed.
- * @param feedbackName Hardware map name of the analog input.
+ * @param feedbackInitializer A function returning the backing [AnalogFeedback]
+ * used to read the feedback angle. Accepts any [AnalogFeedback] implementation.
  * @param cacheTolerance Tolerance for the [NextCRServo] power caching delegate.
  */
 class NextFeedbackCRServo @JvmOverloads constructor(
   initializer: () -> CRServoImplEx,
-  feedbackName: String,
+  feedbackInitializer: () -> AnalogFeedback,
   cacheTolerance: Double = 0.01,
 ) : NextCRServo(initializer, cacheTolerance) {
 
   /**
-   * Constructor to create a NextFeedbackCRServo using a servo name.
+   * Constructor to create a NextFeedbackCRServo using a servo name and an
+   * already-constructed [AnalogFeedback] instance for the feedback input.
    *
    * @param servoName Hardware map name of the servo.
-   * @param feedbackName Hardware map name of the analog input.
+   * @param feedback An already-constructed [AnalogFeedback] instance to read the angle from.
    * @param cacheTolerance Tolerance for the [NextCRServo] power caching delegate.
    */
   @JvmOverloads constructor(
     servoName: String,
-    feedbackName: String,
+    feedback: AnalogFeedback,
     cacheTolerance: Double = 0.01,
   ) : this(
     { RobotController.hardwareMap[servoName] as CRServoImplEx },
-    feedbackName,
+    { feedback },
     cacheTolerance,
   )
 
   /**
-   * Constructor to create a NextFeedbackCRServo using a LynxModule and port number.
+   * Constructor to create a NextFeedbackCRServo using a LynxModule and port number for
+   * the servo, and an already-constructed [AnalogFeedback] instance for the feedback input.
    *
    * @param module The Lynx module, see [RobotController.controlHub], [RobotController.expansionHub],
    * and [RobotController.servoHubs].
    * @param port The servo port (in the range [0, 5]).
-   * @param feedbackName Hardware map name of the analog input.
+   * @param feedback An already-constructed [AnalogFeedback] instance to read the angle from.
    * @param cacheTolerance Tolerance for the [NextCRServo] power caching delegate.
    */
   @JvmOverloads constructor(
     module: NextLynxModule,
     port: Int,
-    feedbackName: String,
+    feedback: AnalogFeedback,
     cacheTolerance: Double = 0.01,
   ) : this(
     {
@@ -77,14 +79,12 @@ class NextFeedbackCRServo @JvmOverloads constructor(
         ServoConfigurationType.getStandardServoType(),
       )
     },
-    feedbackName,
+    { feedback },
     cacheTolerance,
   )
 
-  private val analogInput by LazyHardware {
-    RobotController.hardwareMap[feedbackName] as AnalogInput
-  }
-  private val rawAngleRadians: Double by AnalogFeedback { analogInput.voltage }
+  private val analogInput by LazyHardware(feedbackInitializer)
+  private val rawAngleRadians: Double by analogInput
 
   /**
    * Actual angle of the servo, reported from the analog feedback input.

hardware/src/main/kotlin/dev/nextftc/hardware/actuators/NextFeedbackServo.kt

@@ -8,7 +8,6 @@
 
 package dev.nextftc.hardware.actuators
 
-import com.qualcomm.robotcore.hardware.AnalogInput
 import com.qualcomm.robotcore.hardware.ServoImplEx
 import com.qualcomm.robotcore.hardware.configuration.typecontainers.ServoConfigurationType
 import dev.nextftc.hardware.RobotController
@@ -29,64 +28,65 @@ import dev.nextftc.units.radians
  * Example:
  *
  *  ```
- * val arm = NextFeedbackServo("armServo", "armEncoder")
+ * val arm = NextFeedbackServo("armServo", myAnalogFeedback)
  * arm.position = 0.5
  * val angle = arm.angle
  * ```
  *
  * @param initializer A function returning the backing [ServoImplEx]. It will be
  * invoked lazily the first time the servo is accessed.
- * @param feedbackName Hardware map name of the analog input.
+ * @param feedbackInitializer A function returning the backing [AnalogFeedback]
+ * used to read the feedback angle. Accepts any [AnalogFeedback] implementation.
  * @param cacheTolerance Tolerance for the [NextServo] position caching delegate.
  */
 class NextFeedbackServo @JvmOverloads constructor(
   initializer: () -> ServoImplEx,
-  feedbackName: String,
+  feedbackInitializer: () -> AnalogFeedback,
   cacheTolerance: Double = 0.01,
 ) : NextServo(initializer, cacheTolerance) {
 
   /**
-   * Constructor to create a NextFeedbackServo using a servo name.
+   * Constructor to create a NextFeedbackServo using a servo name and an
+   * already-constructed [AnalogFeedback] instance for the feedback input.
    *
    * @param servoName Hardware map name of the servo.
-   * @param feedbackName Hardware map name of the analog input.
+   * @param feedback An already-constructed [AnalogFeedback] instance to read the angle from.
    * @param cacheTolerance Tolerance for the [NextServo] position caching delegate.
    */
   @JvmOverloads constructor(
     servoName: String,
-    feedbackName: String,
+    feedback: AnalogFeedback,
     cacheTolerance: Double = 0.01,
   ) : this(
     { RobotController.hardwareMap[servoName] as ServoImplEx },
-    feedbackName,
+    { feedback },
     cacheTolerance,
   )
 
   /**
-   * Constructor to create a NextFeedbackServo using a LynxModule and port number.
+   * Constructor to create a NextFeedbackServo using a LynxModule and port number for
+   * the servo, and an already-constructed [AnalogFeedback] instance for the feedback input.
    *
    * @param module The Lynx module, see [RobotController.controlHub], [RobotController.expansionHub],
    * and [RobotController.servoHubs].
    * @param port The servo port (in the range [0, 5]).
-   * @param feedbackName Hardware map name of the analog input.
+   * @param feedback An already-constructed [AnalogFeedback] instance to read the angle from.
    * @param cacheTolerance Tolerance for the [NextServo] position caching delegate.
    */
   @JvmOverloads constructor(
     module: NextLynxModule,
     port: Int,
-    feedbackName: String,
+    feedback: AnalogFeedback,
     cacheTolerance: Double = 0.01,
   ) : this(
     { ServoImplEx(module.servoController, port, ServoConfigurationType.getStandardServoType()) },
-    feedbackName,
+    { feedback },
     cacheTolerance,
   )
 
-  private val analogInput by LazyHardware {
-    RobotController.hardwareMap[feedbackName] as AnalogInput
-  }
+  private val analogInput by LazyHardware(feedbackInitializer)
 
-  private val rawAngleRadians: Double by AnalogFeedback { analogInput.voltage }
+  private val rawAngleRadians: Double by analogInput
 
   /**
    * Actual angle of the servo, reported from the analog feedback input.

hardware/src/main/kotlin/dev/nextftc/hardware/actuators/NextMotor.kt

@@ -77,7 +77,9 @@ class NextMotor @JvmOverloads constructor(
     { DcMotorImplEx(module.motorController, port) },
     anglePerCount,
     cacheTolerance,
-  )
+  ) {
+    require(port in 0..3) { "Expected bus in range [0, 3], got $port" }
+  }
 
   /**
    * Constructs a motor by name from the current hardware map.
@@ -92,7 +94,11 @@ class NextMotor @JvmOverloads constructor(
     name: String,
     anglePerCount: Angle = 1.0.radians,
     cacheTolerance: Double = 0.01,
-  ) : this({ RobotController.hardwareMap[name] as DcMotorImplEx }, anglePerCount, cacheTolerance)
+  ) : this(
+    { RobotController.hardwareMap[name] as DcMotorImplEx },
+    anglePerCount,
+    cacheTolerance,
+  )
 
   init {
     motorEventLoop.bind(this::update)

hardware/src/main/kotlin/dev/nextftc/hardware/actuators/NextRGBIndicator.kt

@@ -8,6 +8,8 @@
 
 package dev.nextftc.hardware.actuators
 
+import dev.nextftc.hardware.RobotController
+import dev.nextftc.hardware.lynx.NextLynxModule
 import dev.nextftc.hardware.util.Caching
 
 /**
@@ -25,12 +27,33 @@ import dev.nextftc.hardware.util.Caching
  * indicator.setBrightness(0.8)
  * ```
  *
- * @param name The name of the servo in the hardware map.
- * @param cacheTolerance Tolerance used by the [Caching] delegate for
- * position updates; defaults to 0.01.
  */
-class NextRGBIndicator @JvmOverloads constructor(name: String, cacheTolerance: Double = 0.01) :
-  NextServo(name, cacheTolerance) {
+class NextRGBIndicator : NextServo {
+
+  /**
+   * @param module The Lynx Module, see [RobotController.controlHub], [RobotController.expansionHub],
+   * and [RobotController.servoHubs]
+   * @param port The servo port (in the range [0, 5])
+   * @param cacheTolerance Tolerance used by the [Caching] delegate for position updates; defaults to 0.01.
+   */
+
+  @JvmOverloads
+  constructor(
+    module: NextLynxModule,
+    port: Int,
+    cacheTolerance: Double = 0.01,
+  ) : super(module, port, cacheTolerance)
+
+  /**
+   * @param name The name of the servo in the hardware map.
+   * @param cacheTolerance Tolerance used by the [Caching] delegate for
+   * position updates; defaults to 0.01.
+   */
+  @JvmOverloads
+  constructor(
+    name: String,
+    cacheTolerance: Double = 0.01,
+  ) : super(name, cacheTolerance)
 
   /**
    * Available colors/patterns for the headlights

hardware/src/main/kotlin/dev/nextftc/hardware/actuators/NextServo.kt

@@ -63,7 +63,9 @@ open class NextServo @JvmOverloads constructor(
     { ServoImplEx(module.servoController, port, ServoConfigurationType.getStandardServoType()) },
     cacheTolerance,
     direction,
-  )
+  ) {
+    require(port in 0..3) { "Expected bus in range [0, 3], got $port" }
+  }
 
   /**
    * Constructor to create a NextServo using configuration name

hardware/src/main/kotlin/dev/nextftc/hardware/lynx/NextLynxModule.kt

@@ -1,6 +1,10 @@
 package dev.nextftc.hardware.lynx
 
+import com.qualcomm.hardware.lynx.LynxAnalogInputController
 import com.qualcomm.hardware.lynx.LynxDcMotorController
+import com.qualcomm.hardware.lynx.LynxDigitalChannelController
+import com.qualcomm.hardware.lynx.LynxI2cDeviceSynch
+import com.qualcomm.hardware.lynx.LynxI2cDeviceSynchV2
 import com.qualcomm.hardware.lynx.LynxModule
 import com.qualcomm.hardware.lynx.LynxServoController
 import dev.nextftc.hardware.RobotController
@@ -26,6 +30,10 @@ class NextLynxModule internal constructor(initializer: () -> LynxModule, @JvmFie
 
   private val module by LazyHardware(initializer)
 
+  private val i2cControllers = Array(4) { bus ->
+    LazyHardware { LynxI2cDeviceSynchV2(RobotController.appContext, module, bus) }
+  }
+
   /** Current module temperature. */
   val temperature: Temperature
     get() = module.getTemperature(TempUnit.CELSIUS).celsius
@@ -47,4 +55,20 @@ class NextLynxModule internal constructor(initializer: () -> LynxModule, @JvmFie
   val servoController: LynxServoController by LazyHardware {
     LynxServoController(RobotController.appContext, module)
   }
+
+  /** Creates or gets a [LynxI2cDeviceSynch] bound to this module. */
+  fun i2cController(bus: Int): LynxI2cDeviceSynch {
+    require(bus in 0..3) { "I2C bus must be in range of 0 - 3, got $bus" }
+    return i2cControllers[bus].getValue(this, ::i2cControllers)
+  }
+
+  /** Creates or gets a [LynxDigitalChannelController] bound to this module. */
+  val digitalController: LynxDigitalChannelController by LazyHardware {
+    LynxDigitalChannelController(RobotController.appContext, module)
+  }
+
+  /** Creates or gets a [LynxAnalogInputController] bound to this module. */
+  val analogController: LynxAnalogInputController by LazyHardware {
+    LynxAnalogInputController(RobotController.appContext, module)
+  }
 }