FTC Codesim [SYNTH-295]

docs/CODE_SIMULATION.md

@@ -24,3 +24,30 @@ You should see updates both in Fission and in the readouts in the code simulator
 The robot code will control the movement of the robot in Fission, and you can expand each of the devices in the robot code simulator GUI to see if their fields are being updated by Fission.
 For example, running the JavaAutoSample should cause the `ADXL362[4]` and `SYN AHRS[0]` devices to update with rotation and acceleration data from Fission
 (note that the names may differ if the code changes).
+
+## FTC Code Simulation
+
+To run:
+
+```
+cd simulation/SyntheSimFTC
+./gradlew run --args="--src <path-to-teamcode-src> [--opmode <name>] [--port <port>]"
+```
+
+`--src` points at a plain directory of `.java` files, rooted so package folders (`org/firstinspires/ftc/teamcode/...`) hang off it. `--port` defaults to `3301`. Make sure to start the simulation before starting the dev server.
+
+`--opmode` picks which discovered OpMode to run, matching a class name (`ExampleDozerArcadeDrive`), or the annotation's display name (`"Dozer Arcade Drive"`).
+
+The runner logs every OpMode it found and which one it selected, e.g.:
+
+```
+[OpModeRunner] Discovered [TeleOp] Dozer Arcade Drive (org.firstinspires.ftc.teamcode.examples.ExampleDozerArcadeDrive)
+[OpModeRunner] Running [TeleOp] Dozer Arcade Drive (org.firstinspires.ftc.teamcode.examples.ExampleDozerArcadeDrive)
+```
+
+Running the Dozer sample at `simulation/samples/FTCDozerArcadeDriveSample`:
+
+```
+cd simulation/SyntheSimFTC
+./gradlew run --args="--src ../samples/FTCDozerArcadeDriveSample --opmode ExampleDozerArcadeDrive"
+```

fission/src/mirabuf/MirabufSceneObject.ts

@@ -250,7 +250,7 @@ class MirabufSceneObject extends SceneObject implements ContextSupplier {
                         this.nameOverride ??
                         (this._brain?.isSynthesis()
                             ? this._brain.inputSchemeName
-                            : this._brain?.isWPILib()
+                            : this._brain?.isWPILib() || this._brain?.isFTC()
                               ? "Magic"
                               : "Not Configured!")
                     if (World.multiplayerSystem != null) {

fission/src/systems/simulation/Brain.ts

@@ -2,7 +2,7 @@ import type Mechanism from "../physics/Mechanism"
 import type SynthesisBrain from "@/systems/simulation/synthesis_brain/SynthesisBrain.ts"
 import type WPILibBrain from "@/systems/simulation/wpilib_brain/WPILibBrain.ts"
 
-export type BrainType = "synthesis" | "wpilib" | "unknown"
+export type BrainType = "synthesis" | "wpilib" | "ftc" | "unknown"
 
 abstract class Brain {
     protected _mechanism: Mechanism
@@ -24,6 +24,9 @@ abstract class Brain {
     public isWPILib(): this is WPILibBrain {
         return this.brainType == "wpilib"
     }
+    public isFTC(): this is WPILibBrain {
+        return this.brainType == "ftc"
+    }
 }
 
 export default Brain

fission/src/systems/simulation/wpilib_brain/WPILibWSWorker.ts → fission/src/systems/simulation/shared/WSWorker.ts

@@ -1,11 +1,14 @@
 import { Mutex } from "async-mutex"
 
+// Generic WebSocket worker shared by WPILib and FTC codesim connections.
+
 let socket: WebSocket | undefined = undefined
 
 const connectMutex = new Mutex()
 
 let intervalHandle: NodeJS.Timeout | undefined = undefined
 let reconnect = false
+let connectionUrl: string | undefined = undefined
 const RECONNECT_INTERVAL = 1000
 
 function socketOpen(): boolean {
@@ -16,13 +19,14 @@ function socketConnecting(): boolean {
     return (socket && socket.readyState == WebSocket.CONNECTING) ?? false
 }
 
-async function tryConnect(port?: number): Promise<void> {
+async function tryConnect(): Promise<void> {
     await connectMutex.runExclusive(() => {
+        if (!connectionUrl) return
         if ((socket?.readyState ?? WebSocket.CLOSED) == WebSocket.OPEN) {
             return
         }
 
-        socket = new WebSocket(`ws://localhost:${port ?? 3300}/wpilibws`)
+        socket = new WebSocket(connectionUrl)
 
         socket.addEventListener("open", () => {
             self.postMessage({ status: "open" })
@@ -47,15 +51,14 @@ async function tryDisconnect(): Promise<void> {
     })
 }
 
-// Posts incoming messages
 function onMessage(event: MessageEvent) {
     self.postMessage(event.data)
 }
 
-// Sends outgoing messages
 self.addEventListener("message", e => {
     switch (e.data.command) {
         case "enable": {
+            connectionUrl = e.data.url ?? connectionUrl
             reconnect = e.data.reconnect ?? false
             const intervalFunc = () => {
                 if (intervalHandle != undefined && !socketOpen() && !socketConnecting()) {

fission/src/systems/simulation/wpilib_brain/WPILibBrain.ts

@@ -83,14 +83,17 @@ class WPILibBrain extends Brain {
         return this._assembly.assemblyId
     }
 
+    private _brainType: "wpilib" | "ftc"
+
     public override get brainType() {
-        return "wpilib" as const
+        return this._brainType
     }
 
-    constructor(assembly: MirabufSceneObject) {
+    constructor(assembly: MirabufSceneObject, brainType: "wpilib" | "ftc" = "wpilib") {
         super(assembly.mechanism)
 
         this._assembly = assembly
+        this._brainType = brainType
 
         this._simLayer = World.simulationSystem.getSimulationLayer(this._mechanism)!
 
@@ -107,7 +110,7 @@ class WPILibBrain extends Brain {
         this.loadSimConfig()
 
         World.sceneRenderer.mirabufSceneObjects.getRobots().forEach(v => {
-            if (v.brain?.isWPILib()) {
+            if (v.brain?.isWPILib() || v.brain?.isFTC()) {
                 v.brain = new SynthesisBrain(v)
             }
         })

fission/src/systems/simulation/wpilib_brain/WPILibState.ts

@@ -1,6 +1,6 @@
 import PreferencesSystem from "@/systems/preferences/PreferencesSystem"
 import type WPILibBrain from "./WPILibBrain"
-import { type SimMap, worker } from "./WPILibTypes"
+import { FTC_WS_URL, type SimMap, WPILIB_WS_URL, worker } from "./WPILibTypes"
 
 export const simMaps = new Map<string, SimMap>()
 
@@ -14,6 +14,7 @@ export function setSimBrain(brain: WPILibBrain | undefined) {
     if (simBrain)
         worker.getValue().postMessage({
             command: "enable",
+            url: simBrain.brainType === "ftc" ? FTC_WS_URL : WPILIB_WS_URL,
             reconnect: PreferencesSystem.getUserPreference("SimAutoReconnect"),
         })
 }
@@ -40,35 +41,3 @@ export function setConnected(connected: boolean) {
 export function getIsConnected() {
     return isConnected
 }
-
-/*
-export const supplierTypeMap: { [k in SimType]: NoraTypes | undefined } = {
-    [SimType.PWM]: NoraTypes.NUMBER,
-    [SimType.SIM_DEVICE]: undefined,
-    [SimType.CAN_MOTOR]: NoraTypes.NUMBER,
-    [SimType.SOLENOID]: NoraTypes.NUMBER,
-    [SimType.CAN_ENCODER]: undefined,
-    [SimType.GYRO]: undefined,
-    [SimType.ACCELEROMETER]: undefined,
-    [SimType.DIO]: NoraTypes.NUMBER, // ?
-    [SimType.AI]: undefined,
-    [SimType.AO]: NoraTypes.NUMBER,
-    [SimType.DRIVERS_STATION]: undefined,
-    [SimType.CAMERA]: undefined,
-}
-
-export const receiverTypeMap: { [k in SimType]: NoraTypes | undefined } = {
-    [SimType.PWM]: undefined,
-    [SimType.SIM_DEVICE]: undefined,
-    [SimType.CAN_MOTOR]: undefined,
-    [SimType.SOLENOID]: undefined,
-    [SimType.CAN_ENCODER]: NoraTypes.NUMBER2,
-    [SimType.GYRO]: NoraTypes.GYRO,
-    [SimType.ACCELEROMETER]: NoraTypes.ACCEL,
-    [SimType.DIO]: NoraTypes.NUMBER, // ?
-    [SimType.AI]: NoraTypes.NUMBER,
-    [SimType.AO]: undefined,
-    [SimType.DRIVERS_STATION]: undefined,
-    [SimType.CAMERA]: undefined,
-}
-*/

fission/src/systems/simulation/wpilib_brain/WPILibTypes.ts

@@ -1,5 +1,8 @@
 import Lazy from "@/util/Lazy.ts"
-import WPILibWSWorker from "./WPILibWSWorker?worker"
+import WSWorker from "../shared/WSWorker?worker"
+
+export const WPILIB_WS_URL = "ws://localhost:3300/wpilibws"
+export const FTC_WS_URL = "ws://localhost:3301/ftcsimws"
 
 export type DeviceName = string
 export type DeviceData = Map<string, number | boolean | string>
@@ -18,6 +21,7 @@ export enum SimType {
     AI = "AI",
     AO = "AO",
     DRIVERS_STATION = "DriverStation",
+    GAMEPAD = "Gamepad",
     CAMERA = "Camera",
 }
 
@@ -63,4 +67,4 @@ export const CAMERA_HEIGHT = "<height"
 export const CAMERA_FPS = "<fps"
 export const CAMERA_CONNECTED = "<connected"
 
-export const worker: Lazy<Worker> = new Lazy<Worker>(() => new WPILibWSWorker())
+export const worker: Lazy<Worker> = new Lazy<Worker>(() => new WSWorker())

fission/src/systems/simulation/wpilib_brain/sim/SimDriverStation.ts

@@ -20,8 +20,8 @@ export default class SimDriverStation {
         const enabled = mode != RobotSimMode.DISABLED
         const autonomous = mode == RobotSimMode.AUTO
         SimGeneric.set<boolean>(SimType.DRIVERS_STATION, "", ">ds", true)
-        SimGeneric.set<boolean>(SimType.DRIVERS_STATION, "", ">enabled", enabled)
         SimGeneric.set<boolean>(SimType.DRIVERS_STATION, "", ">autonomous", autonomous)
+        SimGeneric.set<boolean>(SimType.DRIVERS_STATION, "", ">enabled", enabled)
     }
 
     public static setStation(station: AllianceStation) {

fission/src/systems/simulation/wpilib_brain/sim/SimGamepad.ts

@@ -0,0 +1,83 @@
+import InputSystem from "@/systems/input/InputSystem"
+import type { KeyCode } from "@/systems/input/KeyboardTypes"
+import { SimInput } from "../SimInput"
+import { SimType, worker } from "../WPILibTypes"
+
+const GAMEPAD_AXIS = { LEFT_X: 0, LEFT_Y: 1, RIGHT_X: 2, RIGHT_Y: 3 }
+const GAMEPAD_BUTTON = {
+    A: 0,
+    B: 1,
+    X: 2,
+    Y: 3,
+    LEFT_BUMPER: 4,
+    RIGHT_BUMPER: 5,
+    LEFT_TRIGGER: 6,
+    RIGHT_TRIGGER: 7,
+    BACK: 8,
+    START: 9,
+    DPAD_UP: 12,
+    DPAD_DOWN: 13,
+    DPAD_LEFT: 14,
+    DPAD_RIGHT: 15,
+}
+
+export class SimGamepadInput extends SimInput {
+    public update(_deltaT: number) {
+        const data = InputSystem.gamepad ? this.readPhysicalGamepad() : this.readKeyboardGamepad()
+
+        worker.getValue().postMessage({
+            command: "update",
+            data: { type: SimType.GAMEPAD, device: this._device, data },
+        })
+    }
+
+    private readPhysicalGamepad() {
+        const gamepad = InputSystem.gamepad!
+        return {
+            left_stick_x: InputSystem.getGamepadAxis(GAMEPAD_AXIS.LEFT_X),
+            left_stick_y: InputSystem.getGamepadAxis(GAMEPAD_AXIS.LEFT_Y),
+            right_stick_x: InputSystem.getGamepadAxis(GAMEPAD_AXIS.RIGHT_X),
+            right_stick_y: InputSystem.getGamepadAxis(GAMEPAD_AXIS.RIGHT_Y),
+            left_trigger: gamepad.buttons[GAMEPAD_BUTTON.LEFT_TRIGGER]?.value ?? 0,
+            right_trigger: gamepad.buttons[GAMEPAD_BUTTON.RIGHT_TRIGGER]?.value ?? 0,
+            a: InputSystem.isGamepadButtonPressed(GAMEPAD_BUTTON.A),
+            b: InputSystem.isGamepadButtonPressed(GAMEPAD_BUTTON.B),
+            x: InputSystem.isGamepadButtonPressed(GAMEPAD_BUTTON.X),
+            y: InputSystem.isGamepadButtonPressed(GAMEPAD_BUTTON.Y),
+            left_bumper: InputSystem.isGamepadButtonPressed(GAMEPAD_BUTTON.LEFT_BUMPER),
+            right_bumper: InputSystem.isGamepadButtonPressed(GAMEPAD_BUTTON.RIGHT_BUMPER),
+            dpad_up: InputSystem.isGamepadButtonPressed(GAMEPAD_BUTTON.DPAD_UP),
+            dpad_down: InputSystem.isGamepadButtonPressed(GAMEPAD_BUTTON.DPAD_DOWN),
+            dpad_left: InputSystem.isGamepadButtonPressed(GAMEPAD_BUTTON.DPAD_LEFT),
+            dpad_right: InputSystem.isGamepadButtonPressed(GAMEPAD_BUTTON.DPAD_RIGHT),
+            start: InputSystem.isGamepadButtonPressed(GAMEPAD_BUTTON.START),
+            back: InputSystem.isGamepadButtonPressed(GAMEPAD_BUTTON.BACK),
+        }
+    }
+
+    private readKeyboardGamepad() {
+        const axis = (positiveKey: KeyCode, negativeKey: KeyCode) =>
+            (InputSystem.isKeyPressed(positiveKey) ? 1 : 0) - (InputSystem.isKeyPressed(negativeKey) ? 1 : 0)
+
+        return {
+            left_stick_x: 0,
+            left_stick_y: axis("KeyS", "KeyW"),
+            right_stick_x: axis("KeyD", "KeyA"),
+            right_stick_y: 0,
+            left_trigger: 0,
+            right_trigger: 0,
+            a: false,
+            b: false,
+            x: false,
+            y: false,
+            left_bumper: false,
+            right_bumper: false,
+            dpad_up: false,
+            dpad_down: false,
+            dpad_left: false,
+            dpad_right: false,
+            start: false,
+            back: false,
+        }
+    }
+}

fission/src/ui/components/TopBar.tsx

@@ -29,7 +29,7 @@ import { TopBarFitProvider } from "@/ui/components/topbar/TopBarFitProvider"
 import { TopBarIcon } from "@/ui/components/topbar/TopBarIcons"
 import { useAssemblySelection } from "@/ui/components/topbar/UseConfigureAssembly"
 import UserIcon from "@/ui/components/UserIcon"
-import { hasSimBrain } from "@/systems/simulation/wpilib_brain/WPILibState"
+import { getIsConnected, hasSimBrain } from "@/systems/simulation/wpilib_brain/WPILibState"
 import { useTourAnchor } from "@/ui/tour/TourProviderHelpers"
 
 const TUTORIALS_URL = "https://synthesis.autodesk.com/tutorials"
@@ -183,7 +183,7 @@ const TopBar: React.FC = () => {
 
                     {hasSimBrain() && (
                         <>
-                            <CodeConnectionIndicator />
+                            <CodeConnectionIndicator label="Code connection" getIsConnected={getIsConnected} />
                             <Box sx={TOP_BAR_DIVIDER_SX} />
                         </>
                     )}

fission/src/ui/components/topbar/CodeConnectionIndicator.tsx

@@ -1,20 +1,24 @@
 import { Box, Tooltip } from "@mui/material"
 import type React from "react"
 import { useEffect, useState } from "react"
-import { getIsConnected } from "@/systems/simulation/wpilib_brain/WPILibState"
 import { SynthesisIcons } from "@/ui/components/StyledComponents"
 import { TOP_BAR_GLYPH_SX } from "@/ui/components/topbar/TopBarConfig"
 
-/** small status glyph on the codesim menu reflecting wpilib code connection */
-const CodeConnectionIndicator: React.FC = () => {
+interface CodeConnectionIndicatorProps {
+    label: string
+    getIsConnected: () => boolean
+}
+
+/** small status glyph on the codesim menu reflecting code connection */
+const CodeConnectionIndicator: React.FC<CodeConnectionIndicatorProps> = ({ label, getIsConnected }) => {
     const [connected, setConnected] = useState<boolean>(false)
 
     useEffect(() => {
         const handle = setInterval(() => setConnected(getIsConnected()), 500)
         return () => clearInterval(handle)
-    }, [])
+    }, [getIsConnected])
 
-    const tooltip = connected ? "Code connection: connected" : "Code connection: not connected"
+    const tooltip = connected ? `${label}: connected` : `${label}: not connected`
 
     return (
         // not a TopBarIcon since it is a stateful component

fission/src/ui/components/topbar/CodesimControls.tsx

@@ -12,21 +12,22 @@ type CodesimButton = {
     label: string
     mode: ConfigMode
     icon: React.ReactNode
-    requiresWpilibBrain?: boolean
+    requiresCodesimBrain?: boolean
 }
 
 const CODESIM_BUTTONS: CodesimButton[] = [
     { label: "Brain", mode: ConfigMode.BRAIN, icon: <SynthesisIcons.BRAIN /> },
-    { label: "Simulation", mode: ConfigMode.SIM, icon: <SynthesisIcons.MICROCHIP />, requiresWpilibBrain: true },
+    { label: "Simulation", mode: ConfigMode.SIM, icon: <SynthesisIcons.MICROCHIP />, requiresCodesimBrain: true },
 ]
 
 const CodesimControls: React.FC<{ selectedAssembly?: MirabufSceneObject }> = ({ selectedAssembly }) => {
-    const { isField, isWpilibBrain, openConfig, disabledMessage } = useConfigureAssembly(selectedAssembly)
+    const { isField, isCodesimBrain, openConfig, disabledMessage } = useConfigureAssembly(selectedAssembly)
 
     // codesim is robot only
-    const disabledTooltip = ({ requiresWpilibBrain }: CodesimButton) => {
+    const disabledTooltip = ({ requiresCodesimBrain }: CodesimButton) => {
+        if (!selectedAssembly) return "Spawn an assembly first"
         if (isField) return "Select a robot to configure"
-        if (requiresWpilibBrain && !isWpilibBrain) return "Set this robot's brain to WPILib first"
+        if (requiresCodesimBrain && !isCodesimBrain) return "Set this robot's brain to WPILib or FTC first"
         return undefined
     }