HAL.java

// TODO - RobotCore - Modified file
 
// Copyright (c) FIRST and other WPILib contributors.
// Open Source Software; you can modify and/or share it under the terms of
// the WPILib BSD license file in the root directory of this project.
 
package org.wpilib.hardware.hal;
 
import robotCore.RobotCore;
 
// import java.util.ArrayList;
// import java.util.List;

public final class HAL  {
  public static boolean initialize() {
    // System.out.println("HAL.initialize()");
    // throw new UnsupportedOperationException("Unimplemented method 'initialize'");
    return true;   // TODO - must review;
  }
 
  public static void reportUsage(String resource, String data) {
    // System.out.println(String.format("HAL.reportUsage(%s,%s)", resource, data));
    // throw new UnsupportedOperationException("Unimplemented method 'reportUsage'");
    // TODO - Must review
  }  
 
  public static int publishWpilibVersion(String version) {
    // System.out.println(String.format("publishWpilibVersion(%s)", version));
    // throw new UnsupportedOperationException("Unimplemented method 'publishWpilibVersion'");
    return 0;   // TODO - Must review
  }  
 
  public static boolean hasMain() {
    // System.out.println("hasMain");
    // throw new UnsupportedOperationException("Unimplemented method 'hasMain'");
    return true; // TODO - Must review;
  }
 
  public static void exitMain() {
    throw new UnsupportedOperationException("Unimplemented method 'exitMain'");
    // TODO - Must fix
  } 
 
  public static void runMain() {
    // System.out.println("runMain");
    // throw new UnsupportedOperationException("Unimplemented method 'runMain'");
    // TODO - Must review
    while (true) { RobotCore.sleep(1000); }
  }  
 
  public static void terminate() {
    throw new UnsupportedOperationException("Unimplemented method 'terminate'");
    // TODO - Must fix
  }
 
  public static void shutdown() {
    throw new UnsupportedOperationException("Unimplemented method 'shutdown'");
    // TODO - Must fix
  } 
  
  public static void simPeriodicBefore() {
    throw new UnsupportedOperationException("Unimplemented method 'simPeriodicBefore'");
    // TODO - Must fix
  }  
 
  public static void simPeriodicAfter() {
    throw new UnsupportedOperationException("Unimplemented method 'simPeriodicAfter'");
    // TODO - Must fix
  }  
 
  public static boolean getSystemActive() {
    throw new UnsupportedOperationException("Unimplemented method 'getSystemActive'");
    // return false; // TODO - Must fix
  }
 
  public static  boolean getBrownedOut() {
    throw new UnsupportedOperationException("Unimplemented method 'getBrownedOut'");
    // return false; // TODO - Must fix
  }
 
  public static int getCommsDisableCount() {
    throw new UnsupportedOperationException("Unimplemented method 'getComsDisableCount'");
    // return 0; // TODO - Must fix
  }
 
  public static boolean getRSLState() {
    throw new UnsupportedOperationException("Unimplemented method 'getRLSState'");
    // return false;   // TODO - Must fix
  }
 
  public static boolean getSystemTimeValid() {
    throw new UnsupportedOperationException("Unimplemented method 'getSystemTimeValid'");
    // return false;   // TODO - Must fix
  }
 
  
 
  // /**
  //  * Call this to start up HAL. This is required for robot programs.
  //  *
  //  * <p>This must be called before any other HAL functions. Failure to do so will result in
  //  * undefined behavior, and likely segmentation faults. This means that any statically initialized
  //  * variables in a program MUST call this function in their constructors if they want to use other
  //  * HAL calls.
  //  *
  //  * @return true if initialization was successful, otherwise false.
  //  * @see "HAL_Initialize"
  //  */
  // public static native boolean initialize();
 
  // /**
  //  * Call this to shut down HAL.
  //  *
  //  * <p>This must be called at termination of the robot program to avoid potential segmentation
  //  * faults with simulation extensions at exit.
  //  *
  //  * @see "HAL_Shutdown"
  //  */
  // public static native void shutdown();
 
  // /**
  //  * Returns true if HAL_SetMain() has been called.
  //  *
  //  * @return True if HAL_SetMain() has been called, false otherwise.
  //  * @see "HAL_HasMain"
  //  */
  // public static native boolean hasMain();
 
  // /**
  //  * Runs the main function provided to HAL_SetMain().
  //  *
  //  * <p>If HAL_SetMain() has not been called, simply sleeps until exitMain() is called.
  //  *
  //  * @see "HAL_RunMain"
  //  */
  // public static native void runMain();
 
  // /**
  //  * Causes HAL_RunMain() to exit.
  //  *
  //  * <p>If HAL_SetMain() has been called, this calls the exit function provided to that function.
  //  *
  //  * @see "HAL_ExitMain"
  //  */
  // public static native void exitMain();
 
  // /** Terminates the executable (at the native level). Does nothing in simulation. */
  // public static native void terminate();
 
  // private static native void simPeriodicBeforeNative();
 
  // private static final List<Runnable> s_simPeriodicBefore = new ArrayList<>();
 
  // /** A callback to be run by IterativeRobotBase prior to the user's simulationPeriodic code. */
  // public static final class SimPeriodicBeforeCallback implements AutoCloseable {
  //   private SimPeriodicBeforeCallback(Runnable r) {
  //     m_run = r;
  //   }
 
  //   @Override
  //   public void close() {
  //     synchronized (s_simPeriodicBefore) {
  //       s_simPeriodicBefore.remove(m_run);
  //     }
  //   }
 
  //   private final Runnable m_run;
  // }
 
  // /**
  //  * Registers a callback to be run by IterativeRobotBase prior to the user's simulationPeriodic
  //  * code.
  //  *
  //  * @param r runnable
  //  * @return Callback object (must be retained for callback to stay active).
  //  */
  // public static SimPeriodicBeforeCallback registerSimPeriodicBeforeCallback(Runnable r) {
  //   synchronized (s_simPeriodicBefore) {
  //     s_simPeriodicBefore.add(r);
  //   }
  //   return new SimPeriodicBeforeCallback(r);
  // }
 
  // /**
  //  * Runs SimPeriodicBefore callbacks. IterativeRobotBase calls this prior to the user's
  //  * simulationPeriodic code.
  //  */
  // public static void simPeriodicBefore() {
  //   simPeriodicBeforeNative();
  //   synchronized (s_simPeriodicBefore) {
  //     for (Runnable r : s_simPeriodicBefore) {
  //       r.run();
  //     }
  //   }
  // }
 
  // private static native void simPeriodicAfterNative();
 
  // private static final List<Runnable> s_simPeriodicAfter = new ArrayList<>();
 
  // /** A callback to be run by IterativeRobotBase after the user's simulationPeriodic code. */
  // public static final class SimPeriodicAfterCallback implements AutoCloseable {
  //   private SimPeriodicAfterCallback(Runnable r) {
  //     m_run = r;
  //   }
 
  //   @Override
  //   public void close() {
  //     synchronized (s_simPeriodicAfter) {
  //       s_simPeriodicAfter.remove(m_run);
  //     }
  //   }
 
  //   private final Runnable m_run;
  // }
 
  // /**
  //  * Registers a callback to be run by IterativeRobotBase after the user's simulationPeriodic code.
  //  *
  //  * @param r runnable
  //  * @return Callback object (must be retained for callback to stay active).
  //  */
  // public static SimPeriodicAfterCallback registerSimPeriodicAfterCallback(Runnable r) {
  //   synchronized (s_simPeriodicAfter) {
  //     s_simPeriodicAfter.add(r);
  //   }
  //   return new SimPeriodicAfterCallback(r);
  // }
 
  // /**
  //  * Runs SimPeriodicAfter callbacks. IterativeRobotBase calls this after the user's
  //  * simulationPeriodic code.
  //  */
  // public static void simPeriodicAfter() {
  //   simPeriodicAfterNative();
  //   synchronized (s_simPeriodicAfter) {
  //     for (Runnable r : s_simPeriodicAfter) {
  //       r.run();
  //     }
  //   }
  // }
 
  // /**
  //  * Gets if the system is in a browned out state.
  //  *
  //  * @return true if the system is in a low voltage brown out, false otherwise
  //  * @see "HAL_GetBrownedOut"
  //  */
  // public static native boolean getBrownedOut();
 
  // /**
  //  * Gets if the system outputs are currently active.
  //  *
  //  * @return true if the system outputs are active, false if disabled
  //  * @see "HAL_GetSystemActive"
  //  */
  // public static native boolean getSystemActive();
 
  // /**
  //  * Gets the current state of the Robot Signal Light (RSL).
  //  *
  //  * @return The current state of the RSL- true if on, false if off
  //  * @see "HAL_GetRSLState"
  //  */
  // public static native boolean getRSLState();
 
  // /**
  //  * Gets the number of times the system has been disabled due to communication errors with the
  //  * Driver Station.
  //  *
  //  * @return number of disables due to communication errors.
  //  */
  // public static native int getCommsDisableCount();
 
  // /**
  //  * Gets if the system time is valid.
  //  *
  //  * @return True if the system time is valid, false otherwise
  //  * @see "HAL_GetSystemTimeValid"
  //  */
  // public static native boolean getSystemTimeValid();
 
  // /**
  //  * Reports usage of a resource of interest. Repeated calls for the same resource name replace the
  //  * previous report.
  //  *
  //  * @param resource the used resource name
  //  * @param data arbitrary associated data string
  //  */
  // public static void reportUsage(String resource, String data) {
  //   UsageReportingJNI.report(resource, data);
  // }
 
  // /**
  //  * Reports usage of a resource of interest. Repeated calls for the same resource name replace the
  //  * previous report.
  //  *
  //  * @param resource the used resource name
  //  * @param instanceNumber an index that identifies the resource instance
  //  * @param data arbitrary associated data string
  //  */
  // public static void reportUsage(String resource, int instanceNumber, String data) {
  //   reportUsage(resource + "[" + instanceNumber + "]", data);
  // }
 
  // /**
  //  * Publishes a version for a device on a CAN bus.
  //  *
  //  * @param busId bus containing the device
  //  * @param deviceId device identifier
  //  * @param name version name
  //  * @param version version string
  //  * @return status of the operation
  //  */
  // public static int publishCanVersion(int busId, int deviceId, String name, String version) {
  //   return UsageReportingJNI.publishCanVersion(busId, deviceId, name, version);
  // }
 
  // /**
  //  * Publishes a version without a bus or device identifier.
  //  *
  //  * @param name version name
  //  * @param version version string
  //  * @return status of the operation
  //  */
  // public static int publishVersion(String name, String version) {
  //   return UsageReportingJNI.publishVersion(name, version);
  // }
 
  // /**
  //  * Publishes the WPILib version.
  //  *
  //  * @param version WPILib version string
  //  * @return status of the operation
  //  */
  // public static int publishWpilibVersion(String version) {
  //   return UsageReportingJNI.publishWpilibVersion(version);
  // }
 
  // private HAL() {}
}