Autonomous

.gitignore

@@ -5,6 +5,8 @@
 .idea/**/workspace.xml
 .idea/**/tasks.xml
 .idea/dictionaries
+.idea/
+main/java/main.iml
 
 # Sensitive or high-churn files:
 .idea/**/dataSources/
@@ -32,6 +34,7 @@ cmake-build-debug/
 
 # IntelliJ
 out/
+.idea/
 
 # Project
 src/test/

.travis.yml

@@ -1,5 +1,6 @@
-language: java
-jdk: 
-- oraclejdk8
-before_install:
-- chmod +x gradlew
+language: java
+jdk: 
+- oraclejdk8
+before_install:
+- chmod +x gradlew
+

README.md

@@ -3,6 +3,12 @@
 ![AlloyLogo](http://gdurl.com/AFl8)
 
 Status: **Beta**
+
+
+Alloy is a robot framework designed specifically for the First Tech Challenge (FTC).
+
+Alloy is based off the FRC robot framework [Sprocket](https://github.com/MontclairRobotics/Sprocket), but redesigned to abstract away the more complex ideas but still allow for advanced robot functionality.
+
 Note: Alloy is still under heavy development, and not ready or suggested for use in creating a robot
 
 Developed by FTC147 and FRC555

build.gradle

@@ -52,8 +52,6 @@ spotless {
 
         licenseHeaderFile 'SpotlessLicense'
         paddedCell()
-
-
     }
 }
 

src/main/java/org/montclairrobotics/alloy/auto/AlloyAutonomous.java

@@ -24,20 +24,109 @@ of this software and associated documentation files (the "Software"), to deal
 package org.montclairrobotics.alloy.auto;
 
 import com.qualcomm.robotcore.eventloop.opmode.OpMode;
+import com.qualcomm.robotcore.util.ElapsedTime;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Modifier;
+import java.util.Set;
+import org.montclairrobotics.alloy.core.Alloy;
+import org.montclairrobotics.alloy.core.RobotCore;
+import org.reflections.Reflections;
+import org.reflections.scanners.SubTypesScanner;
 
 /**
  * Created by MHS Robotics on 12/5/2017.
  *
+ * AlloyAutonomous is the core framework for coding auto modes
+ * When an auto mode extends AlloyAutonomous, it needs to override
+ * the setup() method, and has the option of overriding the userLoop()
+ * method. In the setup method, <code>auto<code/> needs to be set to a
+ * state machine, that will be run during the auto mode
+ *
+ * The optional userLoop() method can be used to update or perform
+ * actions every loop, it is called before the state in the state machine
+ *
  * @author Garrett Burroughs
+ * @version 0.1
+ * @since 0.1
  */
 public abstract class AlloyAutonomous extends OpMode {
+
+    /** Keeps track of when the auto mode is running (True after started and before finished) */
+    boolean running;
+
+    /** The actual auto mode that should be instantiated in setup */
+    public StateMachine auto;
+
+    /** A timer to keep track of time in the autoMode */
+    public ElapsedTime timer;
+
+    /**
+     * This is where the user should define all their code and where "Auto", should be instantiated
+     */
+    public abstract void setup();
+
+    /**
+     * Runs when the play button is pressed Start will set up everything that the auto mode needs to
+     * run
+     */
+    @Override
+    public void start() {
+        auto.start(); // run the start method of the state machine
+        running = true; // the state machine has started running
+        timer.reset(); // reset the timer
+    }
+
+    /**
+     * Init is called when the INIT button is pressed on the drivers station. The init method takes
+     * care of setting up global robot variables and running the user setup method
+     */
     @Override
     public void init() {
-        // this code will be run on robot initialization
+        Reflections reflections = new Reflections(new SubTypesScanner());
+        Set<Class<? extends Alloy>> robots = reflections.getSubTypesOf(Alloy.class);
+        for (Class<? extends Alloy> robot : robots) {
+            try {
+                if (!Modifier.isAbstract(robot.getMethod("robotSetup").getModifiers())
+                        || robot.getMethod("robotSetup") == null) {
+                    robot.getMethod("robotSetup").invoke(robot.newInstance());
+                }
+            } catch (NoSuchMethodException
+                    | IllegalAccessException
+                    | InstantiationException
+                    | InvocationTargetException e) {
+                e.printStackTrace();
+            }
+        }
+
+        new RobotCore(telemetry, hardwareMap, gamepad1, gamepad2);
+        setup();
     }
 
+    /**
+     * The user loop can be overridden in the auto mode and is called every loop before the state is
+     * run. This can be useful for updating information used in states.
+     */
+    public void userLoop() {}
+
+    /** the Loop method takes care of running the state machine */
     @Override
     public void loop() {
-        // This code will be run once a loop while the auto mode is running
+        userLoop();
+        if (running) {
+            auto.run(); // Run the state machine, which will in turn run the states
+        }
+        if (auto.isDone()) { // check if the state machine has finished (Last state achieved)
+            running = false; // stop the state machine
+            auto.stop(); // Finally stop the state machine
+        }
+    }
+
+    /**
+     * A wrapper around the add state method to allow the user to add states to the auto mode
+     *
+     * @param state the state to be added
+     */
+    public void newState(State state) {
+        auto.addState(state);
     }
 }

src/main/java/org/montclairrobotics/alloy/auto/README.md

@@ -17,3 +17,6 @@ when they have finished running
 3. Alloy Autonomus - This is the basic framework for alloy auto's. An alloy autonomous takes care of running the state machine<br>
 that the auto is using so all the user has to do is create the state machine and define functionality.
 You can read more about how to use an Alloy Autonomous [Here](https://github.com/GarrettBurroughs/Alloy/wiki/Creating-An-Auto-Mode)
+
+4. Simple Autonomous - A simple autonomous mode further abstracts away auto mode creation allowing 
+for command like auto mode programming. You can read more about how to use a Simple autonomous [Here](https://github.com/GarrettBurroughs/Alloy/wiki/Creating-An-Auto-Mode)

src/main/java/org/montclairrobotics/alloy/auto/SimpleAutonomous.java

@@ -0,0 +1,62 @@
+/*
+MIT License
+
+Copyright (c) 2018 Garrett Burroughs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+package org.montclairrobotics.alloy.auto;
+
+import org.montclairrobotics.alloy.auto.States.ConditionalState;
+import org.montclairrobotics.alloy.auto.States.Drive;
+import org.montclairrobotics.alloy.auto.States.Turn;
+import org.montclairrobotics.alloy.utils.Input;
+import org.montclairrobotics.alloy.vector.Angle;
+
+/**
+ * Created by MHS Robotics on 1/26/2018.
+ *
+ * <p>SimpleAutonomous abstracts away the concept of adding states to a state machine, so that
+ * states can be added as if they were commands to be executed by the auto mode. This class only has
+ * the pre-written states included, so another class extending this one would need to be created to
+ * add any custom states
+ *
+ * @author Garrett Burroughs
+ * @since
+ */
+public class SimpleAutonomous extends AlloyAutonomous {
+    @Override
+    public void setup() {}
+
+    public void drive(double speed, double distance) {
+        addState(new Drive(speed, distance));
+    }
+
+    public void turn(double speed, Angle angle) {
+        addState(new Turn(speed, angle));
+    }
+
+    public void contition(Input<Boolean> condition, State state){
+        addState(new ConditionalState(condition, state));
+    }
+
+    public void addState(State state){
+        auto.addState(state);
+    }
+}

src/main/java/org/montclairrobotics/alloy/auto/State.java

@@ -38,6 +38,8 @@ of this software and associated documentation files (the "Software"), to deal
 public abstract class State {
 
     private Integer nextState = null;
+    protected String debug = "Running State: ";
+    protected String description = "None";
 
     /** The start method is the first thing called when the state is run */
     public abstract void start();
@@ -55,10 +57,33 @@ public abstract class State {
      */
     public abstract boolean isDone();
 
+    /**
+     * In order to have a non linear state machine, the state machine must know what state to go to
+     * when it is done with the previous state. The state also sometimes needs to know the current
+     * state for example if it just wanted to increment the state by one.
+     *
+     * @param currentState the state the state machine is currently running
+     * @return the state the state machine should go to
+     */
     public int getNextState(int currentState) {
         if (nextState != null) {
             return nextState;
         }
         return currentState + 1;
     }
+
+    /**
+     * When a state machine is running, it will debug out information about the state it is running.
+     * It will debug the result of debugInfo
+     *
+     * @param currentState the current state so that it can be used in the debug
+     * @return debug information about the state
+     */
+    public String debugInfo(int currentState) {
+        return debug + currentState;
+    }
+
+    public String verboseDebug() {
+        return description;
+    }
 }