Only reset talons that are newly added

Fixes #5

Author: jhh

src/main/kotlin/org/strykeforce/thirdcoast/Readers.kt

@@ -54,7 +54,7 @@ fun LineReader.readBoolean(prompt: String = PROMPT, default: Boolean = false) =
 }
 
 fun LineReader.readIntList(prompt: String = PROMPT, default: List<Int> = emptyList()): List<Int> = try {
-    val line = this.readLine(prompt, null, default.joinToString(",")).trim()
+    val line = this.readLine(prompt, null, default.joinToString()).trim()
     if (line.isEmpty()) throw EndOfFileException()
     line.split(',').map { it.trim().toInt() }
 } catch (e: Exception) {

src/main/kotlin/org/strykeforce/thirdcoast/device/CanifierService.kt

@@ -8,10 +8,11 @@ class CanifierService(private val telemetryService: TelemetryService, factory: (
     AbstractDeviceService<CANifier>(factory) {
     val timeout = 10
 
-    override fun activate(ids: Collection<Int>) {
-        super.activate(ids)
+    override fun activate(ids: Collection<Int>): Set<Int> {
+        val new = super.activate(ids)
         telemetryService.stop()
         active.forEach { telemetryService.register(CanifierItem(it)) }
         telemetryService.start()
+        return new
     }
 }

src/main/kotlin/org/strykeforce/thirdcoast/device/DeviceService.kt

@@ -5,10 +5,19 @@ import mu.KotlinLogging
 private val logger = KotlinLogging.logger {}
 
 interface DeviceService<T> {
+    /** All previously activated devices. */
     val active: Set<T>
+    /** Currently active devices. */
     val all: Set<T>
+
+    /** Return a activated device, reusing previously activated devices */
     fun get(id: Int): T
-    fun activate(ids: Collection<Int>)
+
+    /** Activate a collection of devices.
+     * @param ids the ids of devices to activate.
+     * @return any devices that were added to the currently active set.
+     */
+    fun activate(ids: Collection<Int>): Set<Int>
 }
 
 open class AbstractDeviceService<T>(private val factory: (id: Int) -> T) :
@@ -27,9 +36,11 @@ open class AbstractDeviceService<T>(private val factory: (id: Int) -> T) :
         return device
     }
 
-    override fun activate(ids: Collection<Int>) {
+    override fun activate(ids: Collection<Int>): Set<Int> {
+        val new = ids.toSet().minus(_active.keys)
         _active.clear()
         ids.associateTo(_active) { id -> id to get(id) }
+        return new
     }
 
     fun idsInAll(ids: Collection<Int>): Set<Int> = _all.keys.intersect(ids)

src/main/kotlin/org/strykeforce/thirdcoast/device/TalonService.kt

@@ -6,8 +6,6 @@ import com.ctre.phoenix.motorcontrol.can.SlotConfiguration
 import com.ctre.phoenix.motorcontrol.can.TalonSRX
 import com.ctre.phoenix.motorcontrol.can.TalonSRXConfiguration
 import mu.KotlinLogging
-import org.strykeforce.thirdcoast.talon.SelectFeedbackSensorCommand
-import org.strykeforce.thirdcoast.talon.TalonParameterCommand
 import org.strykeforce.thirdcoast.telemetry.TelemetryService
 
 private val logger = KotlinLogging.logger {}
@@ -73,18 +71,12 @@ class TalonService(private val telemetryService: TelemetryService, factory: (id:
     val outputInverted: Boolean
         get() = active.firstOrNull()?.inverted ?: OUTPUT_INVERTED_DEFAULT
 
-    override fun activate(ids: Collection<Int>) {
+    override fun activate(ids: Collection<Int>): Set<Int> {
         dirty = true
-        activeSlotIndex = ACTIVE_SLOT_DEFAULT
-        controlMode = CONTROL_MODE_DEFAULT
-        neutralMode = NEUTRAL_MODE_DEFAULT
-        voltageCompensation = VOLTAGE_COMPENSATION_ENABLED_DEFAULT
-        sensorPhase = SENSOR_PHASE_INVERTED_DEFAULT
-        currentLimit = CURRENT_LIMIT_ENABLED_DEFAULT
 
-        super.activate(ids)
+        val new = super.activate(ids)
         telemetryService.stop()
-        active.forEach {
+        active.filter { new.contains(it.deviceID) }.forEach {
             it.setNeutralMode(neutralMode)
             it.selectProfileSlot(activeSlotIndex, 0)
             it.enableVoltageCompensation(voltageCompensation)
@@ -94,5 +86,6 @@ class TalonService(private val telemetryService: TelemetryService, factory: (id:
             telemetryService.register(it)
         }
         telemetryService.start()
+        return new
     }
 }

src/main/kotlin/org/strykeforce/thirdcoast/talon/SelectTalonsCommand.kt

@@ -7,6 +7,7 @@ import org.strykeforce.thirdcoast.command.AbstractCommand
 import org.strykeforce.thirdcoast.command.Command
 import org.strykeforce.thirdcoast.command.prompt
 import org.strykeforce.thirdcoast.device.TalonService
+import org.strykeforce.thirdcoast.info
 import org.strykeforce.thirdcoast.readIntList
 import org.strykeforce.thirdcoast.warn
 
@@ -23,13 +24,12 @@ class SelectTalonsCommand(
     override fun execute(): Command {
         while (true) {
             try {
-                val ids = reader.readIntList(this.prompt("ids"))
-                val seen = talonService.idsInAll(ids)
-                talonService.activate(ids)
-                if (seen.isNotEmpty())
-                    terminal.warn(
+                val ids = reader.readIntList(this.prompt("ids"), talonService.active.map(TalonSRX::getDeviceID))
+                val new = talonService.activate(ids)
+                if (new.isNotEmpty())
+                    terminal.info(
                         "reset control mode, current limit enabled, brake, voltage compensation\nand sensor phase " +
-                                "for talons: ${seen.joinToString()}"
+                                "for talons: ${new.joinToString()}"
                     )
                 return super.execute()
             } catch (e: IllegalArgumentException) {

src/test/kotlin/org/strykeforce/thirdcoast/ReadersTest.kt

@@ -117,7 +117,7 @@ internal class ReadersTest {
         @Test
         fun `read default`() {
             val default = listOf(1, 2)
-            whenever(reader.readLine(any(), isNull(), eq(default.joinToString(","))))
+            whenever(reader.readLine(any(), isNull(), eq(default.joinToString())))
                 .thenReturn("  ")
             assertThat(reader.readIntList(default = default)).containsExactly(1, 2)
         }

src/test/kotlin/org/strykeforce/thirdcoast/device/DeviceServiceTest.kt

@@ -3,20 +3,26 @@ package org.strykeforce.thirdcoast.device
 import com.nhaarman.mockitokotlin2.mock
 import org.assertj.core.api.Assertions.assertThat
 import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.fail
 
 internal class DeviceServiceTest {
 
     @Test
     fun `activate adds devices`() {
         val stringService = AbstractDeviceService { it.toString() }
 
-        stringService.activate(listOf(1, 2, 3, 3))
+        var new = stringService.activate(listOf(1, 2, 3, 3))
         assertThat(stringService.active).containsOnly("1", "2", "3")
         assertThat(stringService.all).containsOnly("1", "2", "3")
+        assertThat(new).containsExactly(1, 2, 3)
 
-        stringService.activate(listOf(4, 5, 4, 5))
+        new = stringService.activate(listOf(4, 5, 4, 5))
         assertThat(stringService.active).containsOnly("4", "5")
         assertThat(stringService.all).containsOnly("1", "2", "3", "4", "5")
+        assertThat(new).containsExactly(4, 5)
+
+        new = stringService.activate(listOf(1, 2, 3, 4, 5))
+        assertThat(new).containsExactly(1, 2, 3)
     }
 
     @Test
@@ -30,6 +36,26 @@ internal class DeviceServiceTest {
         assertThat(stringService.all).containsOnly("1", "2", "3")
     }
 
+    class TestDevice(val id: Int) {
+        companion object {
+            val seen: MutableSet<Int> = mutableSetOf()
+        }
+
+        init {
+            if (!seen.add(id)) fail { "re-instantiating id: $id" }
+        }
+    }
+
+    @Test
+    fun `reactivate seen devices`() {
+        val testService = AbstractDeviceService { id -> TestDevice(id) }
+        testService.activate(listOf(1, 2, 3))
+        assertThat(TestDevice.seen).containsExactly(1, 2, 3)
+        testService.activate(listOf(1))
+        testService.activate(listOf(1, 2, 3, 4))
+        assertThat(TestDevice.seen).containsExactly(1, 2, 3, 4)
+    }
+
     @Test
     fun `service gets same Talon`() {
         val talonService = TalonService(mock()) { mock() }