Panels

repositories {
    maven {
        url = 'https://repo.dairy.foundation/releases'
    }
}

dependencies {
    // Panels (latest: 1.0.12)
    implementation 'com.bylazar:fullpanels:1.0.12'
}

repositories {
    maven {
        url = uri("https://repo.dairy.foundation/releases")
    }
}

dependencies {
    // Panels (latest: 1.0.12)
    implementation("com.bylazar:fullpanels:1.0.12")
}

dependencies {
    // Sloth-compatible Panels
    implementation 'com.bylazar.sloth:fullpanels:0.2.4+1.0.12'
}

dependencies {
    // Sloth-compatible Panels
    implementation("com.bylazar.sloth:fullpanels:0.2.4+1.0.12")
}

import com.bylazar.ftcontrol.annotations.Configurable;

@TeleOp(name = "Tuning Demo")
public class TuningDemo extends LinearOpMode {
    
    // Make variable tunable in Panels
    @Configurable
    public double armPower = 0.5;
    
    @Configurable
    public int targetPosition = 1000;
    
    @Override
    public void runOpMode() {
        DcMotor armMotor = hardwareMap.get(DcMotor.class, "arm");
        
        waitForStart();
        
        while (opModeIsActive()) {
            // Use tunable values - they update in real-time!
            armMotor.setTargetPosition(targetPosition);
            armMotor.setPower(armPower);
            
            telemetry.addData("Arm Power", armPower);
            telemetry.addData("Target", targetPosition);
            telemetry.update();
        }
    }
}

import com.bylazar.ftcontrol.annotations.Configurable

@TeleOp(name = "Tuning Demo")
class TuningDemo : LinearOpMode() {
    
    // Make variable tunable in Panels
    @Configurable
    var armPower = 0.5
    
    @Configurable
    var targetPosition = 1000
    
    override fun runOpMode() {
        val armMotor = hardwareMap.get(DcMotor::class.java, "arm")
        
        waitForStart()
        
        while (opModeIsActive()) {
            // Use tunable values - they update in real-time!
            armMotor.targetPosition = targetPosition
            armMotor.power = armPower
            
            telemetry.addData("Arm Power", armPower)
            telemetry.addData("Target", targetPosition)
            telemetry.update()
        }
    }
}

@TeleOp(name = "Panels Basic")
public class PanelsBasic extends LinearOpMode {
    @Override
    public void runOpMode() {
        DcMotor motor = hardwareMap.get(DcMotor.class, "motor");
        
        waitForStart();
        
        while (opModeIsActive()) {
            double power = -gamepad1.left_stick_y;
            motor.setPower(power);
            
            // Telemetry shows in Panels AND Driver Hub
            telemetry.addData("Motor Power", power);
            telemetry.addData("Position", motor.getCurrentPosition());
            telemetry.update();
        }
    }
}

@TeleOp(name = "Panels Basic")
class PanelsBasic : LinearOpMode() {
    override fun runOpMode() {
        val motor = hardwareMap.get(DcMotor::class.java, "motor")
        
        waitForStart()
        
        while (opModeIsActive()) {
            val power = -gamepad1.left_stick_y
            motor.power = power
            
            // Telemetry shows in Panels AND Driver Hub
            telemetry.addData("Motor Power", power)
            telemetry.addData("Position", motor.currentPosition)
            telemetry.update()
        }
    }
}

import com.bylazar.ftcontrol.field.Field;

@Autonomous(name = "Field Demo")
public class FieldDemo extends LinearOpMode {
    @Override
    public void runOpMode() {
        waitForStart();
        
        // Draw on field (coordinate-mapped)
        Field field = Field.getInstance();
        
        while (opModeIsActive()) {
            // Draw robot position
            field.drawRobot(24, 12, Math.toRadians(90));
            
            // Draw path
            field.drawLine(0, 0, 24, 24);
            field.drawCircle(48, 48, 6);
            
            field.update();
        }
    }
}

import com.bylazar.ftcontrol.field.Field

@Autonomous(name = "Field Demo")
class FieldDemo : LinearOpMode() {
    override fun runOpMode() {
        waitForStart()
        
        // Draw on field (coordinate-mapped)
        val field = Field.getInstance()
        
        while (opModeIsActive()) {
            // Draw robot position
            field.drawRobot(24.0, 12.0, Math.toRadians(90.0))
            
            // Draw path
            field.drawLine(0.0, 0.0, 24.0, 24.0)
            field.drawCircle(48.0, 48.0, 6.0)
            
            field.update()
        }
    }
}

import com.bylazar.ftcontrol.graph.Graph;

@TeleOp(name = "PID Tuning")
public class PIDTuning extends LinearOpMode {
    @Override
    public void runOpMode() {
        Graph graph = Graph.getInstance();
        PIDController controller = new PIDController(0.01, 0.0, 0.0);
        
        waitForStart();
        
        while (opModeIsActive()) {
            double target = 1000;
            double current = motor.getCurrentPosition();
            double output = controller.calculate(current, target);
            
            // Plot on graph
            graph.addPoint("Target", target);
            graph.addPoint("Current", current);
            graph.addPoint("Output", output);
            graph.update();
        }
    }
}

import com.bylazar.ftcontrol.graph.Graph

@TeleOp(name = "PID Tuning")
class PIDTuning : LinearOpMode() {
    override fun runOpMode() {
        val graph = Graph.getInstance()
        val controller = PIDController(0.01, 0.0, 0.0)
        
        waitForStart()
        
        while (opModeIsActive()) {
            val target = 1000.0
            val current = motor.currentPosition.toDouble()
            val output = controller.calculate(current, target)
            
            // Plot on graph
            graph.addPoint("Target", target)
            graph.addPoint("Current", current)
            graph.addPoint("Output", output)
            graph.update()
        }
    }
}

package com.myteam.plugins

import com.bylazar.ftcontrol.plugin.Plugin
import com.bylazar.ftcontrol.plugin.PluginMetadata

@PluginMetadata(
    name = "My Custom Plugin",
    version = "1.0.0",
    description = "Does something cool"
)
class MyPlugin : Plugin {
    override fun init() {
        // Plugin initialization
    }
    
    override fun update() {
        // Called every loop
        val data = computeSomething()
        sendToFrontend("myData", data)
    }
}

<script lang="ts">
  import { onMount } from 'svelte';
  import { panelsAPI } from '$lib/panels';
  
  let myData = 0;
  
  onMount(() => {
    // Listen for backend data
    panelsAPI.on('myData', (data) => {
      myData = data;
    });
  });
</script>

<div class="plugin">
  <h2>My Custom Plugin</h2>
  <p>Data: {myData}</p>
</div>