diff --git a/hal/simjni.gradle b/hal/simjni.gradle index 651cd43dc0..599f0949b7 100644 --- a/hal/simjni.gradle +++ b/hal/simjni.gradle @@ -86,10 +86,9 @@ void SimOnUnload(JavaVM * vm, void* reserved) { } } -//TODO: Add this back in -//static void ThrowSimException(JNIEnv* env) { +static void ThrowSimException(JNIEnv* env) { -//} +} ''' out.println 'extern "C" {' symbolList.each { diff --git a/hal/src/main/java/edu/wpi/first/hal/sim/mockdata/AccelerometerDataJNI.java b/hal/src/main/java/edu/wpi/first/hal/sim/mockdata/AccelerometerDataJNI.java new file mode 100644 index 0000000000..9fe3e8b51d --- /dev/null +++ b/hal/src/main/java/edu/wpi/first/hal/sim/mockdata/AccelerometerDataJNI.java @@ -0,0 +1,40 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +package edu.wpi.first.hal.sim.mockdata; + +import edu.wpi.first.wpilibj.sim.NotifyCallback; +import edu.wpi.first.wpilibj.hal.JNIWrapper; + +public class AccelerometerDataJNI extends JNIWrapper { + public static native int registerActiveCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelActiveCallback(int index, int uid); + public static native boolean getActive(int index); + public static native void setActive(int index, boolean active); + + public static native int registerRangeCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelRangeCallback(int index, int uid); + public static native int getRange(int index); + public static native void setRange(int index, int range); + + public static native int registerXCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelXCallback(int index, int uid); + public static native double getX(int index); + public static native void setX(int index, double x); + + public static native int registerYCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelYCallback(int index, int uid); + public static native double getY(int index); + public static native void setY(int index, double y); + + public static native int registerZCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelZCallback(int index, int uid); + public static native double getZ(int index); + public static native void setZ(int index, double z); + + public static native void resetData(int index); +} diff --git a/hal/src/main/java/edu/wpi/first/hal/sim/mockdata/AnalogGyroDataJNI.java b/hal/src/main/java/edu/wpi/first/hal/sim/mockdata/AnalogGyroDataJNI.java new file mode 100644 index 0000000000..f9794e979a --- /dev/null +++ b/hal/src/main/java/edu/wpi/first/hal/sim/mockdata/AnalogGyroDataJNI.java @@ -0,0 +1,30 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +package edu.wpi.first.hal.sim.mockdata; + +import edu.wpi.first.wpilibj.sim.NotifyCallback; +import edu.wpi.first.wpilibj.hal.JNIWrapper; + +public class AnalogGyroDataJNI extends JNIWrapper { + public static native int registerAngleCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelAngleCallback(int index, int uid); + public static native double getAngle(int index); + public static native void setAngle(int index, double angle); + + public static native int registerRateCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelRateCallback(int index, int uid); + public static native double getRate(int index); + public static native void setRate(int index, double rate); + + public static native int registerInitializedCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelInitializedCallback(int index, int uid); + public static native boolean getInitialized(int index); + public static native void setInitialized(int index, boolean initialized); + + public static native void resetData(int index); +} diff --git a/hal/src/main/java/edu/wpi/first/hal/sim/mockdata/AnalogInDataJNI.java b/hal/src/main/java/edu/wpi/first/hal/sim/mockdata/AnalogInDataJNI.java new file mode 100644 index 0000000000..0e5bfaf0da --- /dev/null +++ b/hal/src/main/java/edu/wpi/first/hal/sim/mockdata/AnalogInDataJNI.java @@ -0,0 +1,60 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +package edu.wpi.first.hal.sim.mockdata; + +import edu.wpi.first.wpilibj.sim.NotifyCallback; +import edu.wpi.first.wpilibj.hal.JNIWrapper; + +public class AnalogInDataJNI extends JNIWrapper { + public static native int registerInitializedCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelInitializedCallback(int index, int uid); + public static native boolean getInitialized(int index); + public static native void setInitialized(int index, boolean initialized); + + public static native int registerAverageBitsCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelAverageBitsCallback(int index, int uid); + public static native int getAverageBits(int index); + public static native void setAverageBits(int index, int averageBits); + + public static native int registerOversampleBitsCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelOversampleBitsCallback(int index, int uid); + public static native int getOversampleBits(int index); + public static native void setOversampleBits(int index, int oversampleBits); + + public static native int registerVoltageCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelVoltageCallback(int index, int uid); + public static native double getVoltage(int index); + public static native void setVoltage(int index, double voltage); + + public static native int registerAccumulatorInitializedCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelAccumulatorInitializedCallback(int index, int uid); + public static native boolean getAccumulatorInitialized(int index); + public static native void setAccumulatorInitialized(int index, boolean accumulatorInitialized); + + public static native int registerAccumulatorValueCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelAccumulatorValueCallback(int index, int uid); + public static native long getAccumulatorValue(int index); + public static native void setAccumulatorValue(int index, long accumulatorValue); + + public static native int registerAccumulatorCountCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelAccumulatorCountCallback(int index, int uid); + public static native long getAccumulatorCount(int index); + public static native void setAccumulatorCount(int index, long accumulatorCount); + + public static native int registerAccumulatorCenterCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelAccumulatorCenterCallback(int index, int uid); + public static native int getAccumulatorCenter(int index); + public static native void setAccumulatorCenter(int index, int AccumulatorCenter); + + public static native int registerAccumulatorDeadbandCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelAccumulatorDeadbandCallback(int index, int uid); + public static native int getAccumulatorDeadband(int index); + public static native void setAccumulatorDeadband(int index, int AccumulatorDeadband); + + public static native void resetData(int index); +} diff --git a/hal/src/main/java/edu/wpi/first/hal/sim/mockdata/AnalogOutDataJNI.java b/hal/src/main/java/edu/wpi/first/hal/sim/mockdata/AnalogOutDataJNI.java new file mode 100644 index 0000000000..1f9f9b337d --- /dev/null +++ b/hal/src/main/java/edu/wpi/first/hal/sim/mockdata/AnalogOutDataJNI.java @@ -0,0 +1,25 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +package edu.wpi.first.hal.sim.mockdata; + +import edu.wpi.first.wpilibj.sim.NotifyCallback; +import edu.wpi.first.wpilibj.hal.JNIWrapper; + +public class AnalogOutDataJNI extends JNIWrapper { + public static native int registerVoltageCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelVoltageCallback(int index, int uid); + public static native double getVoltage(int index); + public static native void setVoltage(int index, double voltage); + + public static native int registerInitializedCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelInitializedCallback(int index, int uid); + public static native boolean getInitialized(int index); + public static native void setInitialized(int index, boolean initialized); + + public static native void resetData(int index); +} diff --git a/hal/src/main/java/edu/wpi/first/hal/sim/mockdata/AnalogTriggerDataJNI.java b/hal/src/main/java/edu/wpi/first/hal/sim/mockdata/AnalogTriggerDataJNI.java new file mode 100644 index 0000000000..19d59116af --- /dev/null +++ b/hal/src/main/java/edu/wpi/first/hal/sim/mockdata/AnalogTriggerDataJNI.java @@ -0,0 +1,30 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +package edu.wpi.first.hal.sim.mockdata; + +import edu.wpi.first.wpilibj.sim.NotifyCallback; +import edu.wpi.first.wpilibj.hal.JNIWrapper; + +public class AnalogTriggerDataJNI extends JNIWrapper { + public static native int registerInitializedCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelInitializedCallback(int index, int uid); + public static native boolean getInitialized(int index); + public static native void setInitialized(int index, boolean initialized); + + public static native int registerTriggerLowerBoundCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelTriggerLowerBoundCallback(int index, int uid); + public static native double getTriggerLowerBound(int index); + public static native void setTriggerLowerBound(int index, double triggerLowerBound); + + public static native int registerTriggerUpperBoundCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelTriggerUpperBoundCallback(int index, int uid); + public static native double getTriggerUpperBound(int index); + public static native void setTriggerUpperBound(int index, double triggerUpperBound); + + public static native void resetData(int index); +} diff --git a/hal/src/main/java/edu/wpi/first/hal/sim/mockdata/DIODataJNI.java b/hal/src/main/java/edu/wpi/first/hal/sim/mockdata/DIODataJNI.java new file mode 100644 index 0000000000..e49f35b95d --- /dev/null +++ b/hal/src/main/java/edu/wpi/first/hal/sim/mockdata/DIODataJNI.java @@ -0,0 +1,40 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +package edu.wpi.first.hal.sim.mockdata; + +import edu.wpi.first.wpilibj.sim.NotifyCallback; +import edu.wpi.first.wpilibj.hal.JNIWrapper; + +public class DIODataJNI extends JNIWrapper { + public static native int registerInitializedCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelInitializedCallback(int index, int uid); + public static native boolean getInitialized(int index); + public static native void setInitialized(int index, boolean initialized); + + public static native int registerValueCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelValueCallback(int index, int uid); + public static native boolean getValue(int index); + public static native void setValue(int index, boolean value); + + public static native int registerPulseLengthCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelPulseLengthCallback(int index, int uid); + public static native double getPulseLength(int index); + public static native void setPulseLength(int index, double pulseLength); + + public static native int registerIsInputCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelIsInputCallback(int index, int uid); + public static native boolean getIsInput(int index); + public static native void setIsInput(int index, boolean isInput); + + public static native int registerFilterIndexCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelFilterIndexCallback(int index, int uid); + public static native int getFilterIndex(int index); + public static native void setFilterIndex(int index, int filterIndex); + + public static native void resetData(int index); +} diff --git a/hal/src/main/java/edu/wpi/first/hal/sim/mockdata/DigitalPWMDataJNI.java b/hal/src/main/java/edu/wpi/first/hal/sim/mockdata/DigitalPWMDataJNI.java new file mode 100644 index 0000000000..6ca30b0b37 --- /dev/null +++ b/hal/src/main/java/edu/wpi/first/hal/sim/mockdata/DigitalPWMDataJNI.java @@ -0,0 +1,30 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +package edu.wpi.first.hal.sim.mockdata; + +import edu.wpi.first.wpilibj.sim.NotifyCallback; +import edu.wpi.first.wpilibj.hal.JNIWrapper; + +public class DigitalPWMDataJNI extends JNIWrapper { + public static native int registerInitializedCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelInitializedCallback(int index, int uid); + public static native boolean getInitialized(int index); + public static native void setInitialized(int index, boolean initialized); + + public static native int registerDutyCycleCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelDutyCycleCallback(int index, int uid); + public static native double getDutyCycle(int index); + public static native void setDutyCycle(int index, double dutyCycle); + + public static native int registerPinCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelPinCallback(int index, int uid); + public static native int getPin(int index); + public static native void setPin(int index, int pin); + + public static native void resetData(int index); +} diff --git a/hal/src/main/java/edu/wpi/first/hal/sim/mockdata/DriverStationDataJNI.java b/hal/src/main/java/edu/wpi/first/hal/sim/mockdata/DriverStationDataJNI.java new file mode 100644 index 0000000000..448be75a4f --- /dev/null +++ b/hal/src/main/java/edu/wpi/first/hal/sim/mockdata/DriverStationDataJNI.java @@ -0,0 +1,54 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +package edu.wpi.first.hal.sim.mockdata; + +import edu.wpi.first.wpilibj.sim.NotifyCallback; +import edu.wpi.first.wpilibj.hal.JNIWrapper; +import edu.wpi.first.wpilibj.hal.MatchInfoData; + +public class DriverStationDataJNI extends JNIWrapper { + public static native int registerEnabledCallback(NotifyCallback callback, boolean initialNotify); + public static native void cancelEnabledCallback(int uid); + public static native boolean getEnabled(); + public static native void setEnabled(boolean enabled); + + public static native int registerAutonomousCallback(NotifyCallback callback, boolean initialNotify); + public static native void cancelAutonomousCallback(int uid); + public static native boolean getAutonomous(); + public static native void setAutonomous(boolean autonomous); + + public static native int registerTestCallback(NotifyCallback callback, boolean initialNotify); + public static native void cancelTestCallback(int uid); + public static native boolean getTest(); + public static native void setTest(boolean test); + + public static native int registerEStopCallback(NotifyCallback callback, boolean initialNotify); + public static native void cancelEStopCallback(int uid); + public static native boolean getEStop(); + public static native void setEStop(boolean eStop); + + public static native int registerFmsAttachedCallback(NotifyCallback callback, boolean initialNotify); + public static native void cancelFmsAttachedCallback(int uid); + public static native boolean getFmsAttached(); + public static native void setFmsAttached(boolean fmsAttached); + + public static native int registerDsAttachedCallback(NotifyCallback callback, boolean initialNotify); + public static native void cancelDsAttachedCallback(int uid); + public static native boolean getDsAttached(); + public static native void setDsAttached(boolean dsAttached); + + public static native void setJoystickAxes(byte joystickNum, float[] axesArray); + public static native void setJoystickPOVs(byte joystickNum, short[] povsArray); + public static native void setJoystickButtons(byte joystickNum, int buttons, int count); + + public static native void setMatchInfo(MatchInfoData info); + public static native void registerAllCallbacks(NotifyCallback callback, boolean initialNotify); + public static native void notifyNewData(); + + public static native void resetData(); +} diff --git a/hal/src/main/java/edu/wpi/first/hal/sim/mockdata/EncoderDataJNI.java b/hal/src/main/java/edu/wpi/first/hal/sim/mockdata/EncoderDataJNI.java new file mode 100644 index 0000000000..762c51f294 --- /dev/null +++ b/hal/src/main/java/edu/wpi/first/hal/sim/mockdata/EncoderDataJNI.java @@ -0,0 +1,55 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +package edu.wpi.first.hal.sim.mockdata; + +import edu.wpi.first.wpilibj.sim.NotifyCallback; +import edu.wpi.first.wpilibj.hal.JNIWrapper; + +public class EncoderDataJNI extends JNIWrapper { + public static native int registerInitializedCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelInitializedCallback(int index, int uid); + public static native boolean getInitialized(int index); + public static native void setInitialized(int index, boolean initialized); + + public static native int registerCountCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelCountCallback(int index, int uid); + public static native int getCount(int index); + public static native void setCount(int index, int count); + + public static native int registerPeriodCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelPeriodCallback(int index, int uid); + public static native double getPeriod(int index); + public static native void setPeriod(int index, double period); + + public static native int registerResetCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelResetCallback(int index, int uid); + public static native boolean getReset(int index); + public static native void setReset(int index, boolean reset); + + public static native int registerMaxPeriodCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelMaxPeriodCallback(int index, int uid); + public static native double getMaxPeriod(int index); + public static native void setMaxPeriod(int index, double maxPeriod); + + public static native int registerDirectionCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelDirectionCallback(int index, int uid); + public static native boolean getDirection(int index); + public static native void setDirection(int index, boolean direction); + + public static native int registerReverseDirectionCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelReverseDirectionCallback(int index, int uid); + public static native boolean getReverseDirection(int index); + public static native void setReverseDirection(int index, boolean reverseDirection); + + public static native int registerSamplesToAverageCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelSamplesToAverageCallback(int index, int uid); + public static native int getSamplesToAverage(int index); + public static native void setSamplesToAverage(int index, int samplesToAverage); + + public static native void resetData(int index); +} diff --git a/hal/src/main/java/edu/wpi/first/hal/sim/mockdata/I2CDataJNI.java b/hal/src/main/java/edu/wpi/first/hal/sim/mockdata/I2CDataJNI.java new file mode 100644 index 0000000000..ed2f65578f --- /dev/null +++ b/hal/src/main/java/edu/wpi/first/hal/sim/mockdata/I2CDataJNI.java @@ -0,0 +1,28 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +package edu.wpi.first.hal.sim.mockdata; + +import edu.wpi.first.wpilibj.sim.BufferCallback; +import edu.wpi.first.wpilibj.sim.ConstBufferCallback; +import edu.wpi.first.wpilibj.sim.NotifyCallback; +import edu.wpi.first.wpilibj.hal.JNIWrapper; + +public class I2CDataJNI extends JNIWrapper { + public static native int registerInitializedCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelInitializedCallback(int index, int uid); + public static native boolean getInitialized(int index); + public static native void setInitialized(int index, boolean initialized); + + public static native int registerReadCallback(int index, BufferCallback callback); + public static native void cancelReadCallback(int index, int uid); + + public static native int registerWriteCallback(int index, ConstBufferCallback callback); + public static native void cancelWriteCallback(int index, int uid); + + public static native void resetData(int index); +} diff --git a/hal/src/main/java/edu/wpi/first/hal/sim/mockdata/PCMDataJNI.java b/hal/src/main/java/edu/wpi/first/hal/sim/mockdata/PCMDataJNI.java new file mode 100644 index 0000000000..1ab5426f6b --- /dev/null +++ b/hal/src/main/java/edu/wpi/first/hal/sim/mockdata/PCMDataJNI.java @@ -0,0 +1,53 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +package edu.wpi.first.hal.sim.mockdata; + +import edu.wpi.first.wpilibj.sim.NotifyCallback; +import edu.wpi.first.wpilibj.hal.JNIWrapper; + +public class PCMDataJNI extends JNIWrapper { + public static native int registerSolenoidInitializedCallback(int index, int channel, NotifyCallback callback, boolean initialNotify); + public static native void cancelSolenoidInitializedCallback(int index, int channel, int uid); + public static native boolean getSolenoidInitialized(int index, int channel); + public static native void setSolenoidInitialized(int index, int channel, boolean solenoidInitialized); + + public static native int registerSolenoidOutputCallback(int index, int channel, NotifyCallback callback, boolean initialNotify); + public static native void cancelSolenoidOutputCallback(int index, int channel, int uid); + public static native boolean getSolenoidOutput(int index, int channel); + public static native void setSolenoidOutput(int index, int channel, boolean solenoidOutput); + + public static native int registerCompressorInitializedCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelCompressorInitializedCallback(int index, int uid); + public static native boolean getCompressorInitialized(int index); + public static native void setCompressorInitialized(int index, boolean compressorInitialized); + + public static native int registerCompressorOnCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelCompressorOnCallback(int index, int uid); + public static native boolean getCompressorOn(int index); + public static native void setCompressorOn(int index, boolean compressorOn); + + public static native int registerClosedLoopEnabledCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelClosedLoopEnabledCallback(int index, int uid); + public static native boolean getClosedLoopEnabled(int index); + public static native void setClosedLoopEnabled(int index, boolean closeLoopEnabled); + + public static native int registerPressureSwitchCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelPressureSwitchCallback(int index, int uid); + public static native boolean getPressureSwitch(int index); + public static native void setPressureSwitch(int index, boolean pressureSwitch); + + public static native int registerCompressorCurrentCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelCompressorCurrentCallback(int index, int uid); + public static native double getCompressorCurrent(int index); + public static native void setCompressorCurrent(int index, double compressorCurrent); + + public static native void registerAllNonSolenoidCallbacks(int index, NotifyCallback callback, boolean initialNotify); + public static native void registerAllSolenoidCallbacks(int index, int channel, NotifyCallback callback, boolean initialNotify); + + public static native void resetData(int index); +} diff --git a/hal/src/main/java/edu/wpi/first/hal/sim/mockdata/PDPDataJNI.java b/hal/src/main/java/edu/wpi/first/hal/sim/mockdata/PDPDataJNI.java new file mode 100644 index 0000000000..6f7bc437c2 --- /dev/null +++ b/hal/src/main/java/edu/wpi/first/hal/sim/mockdata/PDPDataJNI.java @@ -0,0 +1,36 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +package edu.wpi.first.hal.sim.mockdata; + +import edu.wpi.first.wpilibj.sim.NotifyCallback; +import edu.wpi.first.wpilibj.hal.JNIWrapper; + +public class PDPDataJNI extends JNIWrapper { + public static native int registerInitializedCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelInitializedCallback(int index, int uid); + public static native boolean getInitialized(int index); + public static native void setInitialized(int index, boolean initialized); + + public static native int registerTemperatureCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelTemperatureCallback(int index, int uid); + public static native double getTemperature(int index); + public static native void setTemperature(int index, double temperature); + + public static native int registerVoltageCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelVoltageCallback(int index, int uid); + public static native double getVoltage(int index); + public static native void setVoltage(int index, double voltage); + + + public static native int registerCurrentCallback(int index, int channel, NotifyCallback callback, boolean initialNotify); + public static native void cancelCurrentCallback(int index, int channel, int uid); + public static native double getCurrent(int index, int channel); + public static native void setCurrent(int index, int channel, double current); + + public static native void resetData(int index); +} diff --git a/hal/src/main/java/edu/wpi/first/hal/sim/mockdata/PWMDataJNI.java b/hal/src/main/java/edu/wpi/first/hal/sim/mockdata/PWMDataJNI.java new file mode 100644 index 0000000000..1a8e2cbc13 --- /dev/null +++ b/hal/src/main/java/edu/wpi/first/hal/sim/mockdata/PWMDataJNI.java @@ -0,0 +1,45 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +package edu.wpi.first.hal.sim.mockdata; + +import edu.wpi.first.wpilibj.sim.NotifyCallback; +import edu.wpi.first.wpilibj.hal.JNIWrapper; + +public class PWMDataJNI extends JNIWrapper { + public static native int registerInitializedCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelInitializedCallback(int index, int uid); + public static native boolean getInitialized(int index); + public static native void setInitialized(int index, boolean initialized); + + public static native int registerRawValueCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelRawValueCallback(int index, int uid); + public static native int getRawValue(int index); + public static native void setRawValue(int index, int rawValue); + + public static native int registerSpeedCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelSpeedCallback(int index, int uid); + public static native double getSpeed(int index); + public static native void setSpeed(int index, double speed); + + public static native int registerPositionCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelPositionCallback(int index, int uid); + public static native double getPosition(int index); + public static native void setPosition(int index, double position); + + public static native int registerPeriodScaleCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelPeriodScaleCallback(int index, int uid); + public static native int getPeriodScale(int index); + public static native void setPeriodScale(int index, int periodScale); + + public static native int registerZeroLatchCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelZeroLatchCallback(int index, int uid); + public static native boolean getZeroLatch(int index); + public static native void setZeroLatch(int index, boolean zeroLatch); + + public static native void resetData(int index); +} diff --git a/hal/src/main/java/edu/wpi/first/hal/sim/mockdata/RelayDataJNI.java b/hal/src/main/java/edu/wpi/first/hal/sim/mockdata/RelayDataJNI.java new file mode 100644 index 0000000000..ccee830727 --- /dev/null +++ b/hal/src/main/java/edu/wpi/first/hal/sim/mockdata/RelayDataJNI.java @@ -0,0 +1,35 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +package edu.wpi.first.hal.sim.mockdata; + +import edu.wpi.first.wpilibj.sim.NotifyCallback; +import edu.wpi.first.wpilibj.hal.JNIWrapper; + +public class RelayDataJNI extends JNIWrapper { + public static native int registerInitializedForwardCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelInitializedForwardCallback(int index, int uid); + public static native boolean getInitializedForward(int index); + public static native void setInitializedForward(int index, boolean initializedForward); + + public static native int registerInitializedReverseCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelInitializedReverseCallback(int index, int uid); + public static native boolean getInitializedReverse(int index); + public static native void setInitializedReverse(int index, boolean initializedReverse); + + public static native int registerForwardCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelForwardCallback(int index, int uid); + public static native boolean getForward(int index); + public static native void setForward(int index, boolean forward); + + public static native int registerReverseCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelReverseCallback(int index, int uid); + public static native boolean getReverse(int index); + public static native void setReverse(int index, boolean reverse); + + public static native void resetData(int index); +} diff --git a/hal/src/main/java/edu/wpi/first/hal/sim/mockdata/RoboRioDataJNI.java b/hal/src/main/java/edu/wpi/first/hal/sim/mockdata/RoboRioDataJNI.java new file mode 100644 index 0000000000..b56c6f24ee --- /dev/null +++ b/hal/src/main/java/edu/wpi/first/hal/sim/mockdata/RoboRioDataJNI.java @@ -0,0 +1,90 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +package edu.wpi.first.hal.sim.mockdata; + +import edu.wpi.first.wpilibj.sim.NotifyCallback; +import edu.wpi.first.wpilibj.hal.JNIWrapper; + +public class RoboRioDataJNI extends JNIWrapper { + public static native int registerFPGAButtonCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelFPGAButtonCallback(int index, int uid); + public static native boolean getFPGAButton(int index); + public static native void setFPGAButton(int index, boolean fPGAButton); + + public static native int registerVInVoltageCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelVInVoltageCallback(int index, int uid); + public static native double getVInVoltage(int index); + public static native void setVInVoltage(int index, double vInVoltage); + + public static native int registerVInCurrentCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelVInCurrentCallback(int index, int uid); + public static native double getVInCurrent(int index); + public static native void setVInCurrent(int index, double vInCurrent); + + public static native int registerUserVoltage6VCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelUserVoltage6VCallback(int index, int uid); + public static native double getUserVoltage6V(int index); + public static native void setUserVoltage6V(int index, double userVoltage6V); + + public static native int registerUserCurrent6VCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelUserCurrent6VCallback(int index, int uid); + public static native double getUserCurrent6V(int index); + public static native void setUserCurrent6V(int index, double userCurrent6V); + + public static native int registerUserActive6VCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelUserActive6VCallback(int index, int uid); + public static native boolean getUserActive6V(int index); + public static native void setUserActive6V(int index, boolean userActive6V); + + public static native int registerUserVoltage5VCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelUserVoltage5VCallback(int index, int uid); + public static native double getUserVoltage5V(int index); + public static native void setUserVoltage5V(int index, double userVoltage5V); + + public static native int registerUserCurrent5VCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelUserCurrent5VCallback(int index, int uid); + public static native double getUserCurrent5V(int index); + public static native void setUserCurrent5V(int index, double userCurrent5V); + + public static native int registerUserActive5VCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelUserActive5VCallback(int index, int uid); + public static native boolean getUserActive5V(int index); + public static native void setUserActive5V(int index, boolean userActive5V); + + public static native int registerUserVoltage3V3Callback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelUserVoltage3V3Callback(int index, int uid); + public static native double getUserVoltage3V3(int index); + public static native void setUserVoltage3V3(int index, double userVoltage3V3); + + public static native int registerUserCurrent3V3Callback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelUserCurrent3V3Callback(int index, int uid); + public static native double getUserCurrent3V3(int index); + public static native void setUserCurrent3V3(int index, double userCurrent3V3); + + public static native int registerUserActive3V3Callback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelUserActive3V3Callback(int index, int uid); + public static native boolean getUserActive3V3(int index); + public static native void setUserActive3V3(int index, boolean userActive3V3); + + public static native int registerUserFaults6VCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelUserFaults6VCallback(int index, int uid); + public static native int getUserFaults6V(int index); + public static native void setUserFaults6V(int index, int userFaults6V); + + public static native int registerUserFaults5VCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelUserFaults5VCallback(int index, int uid); + public static native int getUserFaults5V(int index); + public static native void setUserFaults5V(int index, int userFaults5V); + + public static native int registerUserFaults3V3Callback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelUserFaults3V3Callback(int index, int uid); + public static native int getUserFaults3V3(int index); + public static native void setUserFaults3V3(int index, int userFaults3V3); + + public static native void resetData(int index); +} diff --git a/hal/src/main/java/edu/wpi/first/hal/sim/mockdata/SPIAccelerometerDataJNI.java b/hal/src/main/java/edu/wpi/first/hal/sim/mockdata/SPIAccelerometerDataJNI.java new file mode 100644 index 0000000000..5b266235d8 --- /dev/null +++ b/hal/src/main/java/edu/wpi/first/hal/sim/mockdata/SPIAccelerometerDataJNI.java @@ -0,0 +1,40 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +package edu.wpi.first.hal.sim.mockdata; + +import edu.wpi.first.wpilibj.sim.NotifyCallback; +import edu.wpi.first.wpilibj.hal.JNIWrapper; + +public class SPIAccelerometerDataJNI extends JNIWrapper { + public static native int registerActiveCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelActiveCallback(int index, int uid); + public static native boolean getActive(int index); + public static native void setActive(int index, boolean active); + + public static native int registerRangeCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelRangeCallback(int index, int uid); + public static native int getRange(int index); + public static native void setRange(int index, int range); + + public static native int registerXCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelXCallback(int index, int uid); + public static native double getX(int index); + public static native void setX(int index, double x); + + public static native int registerYCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelYCallback(int index, int uid); + public static native double getY(int index); + public static native void setY(int index, double y); + + public static native int registerZCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelZCallback(int index, int uid); + public static native double getZ(int index); + public static native void setZ(int index, double z); + + public static native void resetData(int index); +} diff --git a/hal/src/main/java/edu/wpi/first/hal/sim/mockdata/SPIDataJNI.java b/hal/src/main/java/edu/wpi/first/hal/sim/mockdata/SPIDataJNI.java new file mode 100644 index 0000000000..40d070db84 --- /dev/null +++ b/hal/src/main/java/edu/wpi/first/hal/sim/mockdata/SPIDataJNI.java @@ -0,0 +1,32 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +package edu.wpi.first.hal.sim.mockdata; + +import edu.wpi.first.wpilibj.sim.BufferCallback; +import edu.wpi.first.wpilibj.sim.ConstBufferCallback; +import edu.wpi.first.wpilibj.sim.NotifyCallback; +import edu.wpi.first.wpilibj.sim.SpiReadAutoReceiveBufferCallback; +import edu.wpi.first.wpilibj.hal.JNIWrapper; + +public class SPIDataJNI extends JNIWrapper { + public static native int registerInitializedCallback(int index, NotifyCallback callback, boolean initialNotify); + public static native void cancelInitializedCallback(int index, int uid); + public static native boolean getInitialized(int index); + public static native void setInitialized(int index, boolean initialized); + + public static native int registerReadCallback(int index, BufferCallback callback); + public static native void cancelReadCallback(int index, int uid); + + public static native int registerWriteCallback(int index, ConstBufferCallback callback); + public static native void cancelWriteCallback(int index, int uid); + + public static native int registerReadAutoReceiveBufferCallback(int index, SpiReadAutoReceiveBufferCallback callback); + public static native void cancelReadAutoReceiveBufferCallback(int index, int uid); + + public static native void resetData(int index); +} diff --git a/hal/src/main/java/edu/wpi/first/hal/sim/mockdata/SimulatorJNI.java b/hal/src/main/java/edu/wpi/first/hal/sim/mockdata/SimulatorJNI.java new file mode 100644 index 0000000000..bfc2293fe5 --- /dev/null +++ b/hal/src/main/java/edu/wpi/first/hal/sim/mockdata/SimulatorJNI.java @@ -0,0 +1,17 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +package edu.wpi.first.hal.sim.mockdata; + +import edu.wpi.first.wpilibj.hal.JNIWrapper; + +public class SimulatorJNI extends JNIWrapper { + public static native void waitForProgramStart(); + public static native void setProgramStarted(); + public static native void restartTiming(); + public static native void resetHandles(); +} diff --git a/hal/src/main/java/edu/wpi/first/wpilibj/sim/AccelerometerSim.java b/hal/src/main/java/edu/wpi/first/wpilibj/sim/AccelerometerSim.java new file mode 100644 index 0000000000..97409e6997 --- /dev/null +++ b/hal/src/main/java/edu/wpi/first/wpilibj/sim/AccelerometerSim.java @@ -0,0 +1,77 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +package edu.wpi.first.wpilibj.sim; + +import edu.wpi.first.hal.sim.mockdata.AccelerometerDataJNI; + +public class AccelerometerSim { + private int m_index; + + public AccelerometerSim() { + m_index = 0; + } + + public CallbackStore registerActiveCallback(NotifyCallback callback, boolean initialNotify) { + int uid = AccelerometerDataJNI.registerActiveCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, AccelerometerDataJNI::cancelActiveCallback); + } + public boolean getActive() { + return AccelerometerDataJNI.getActive(m_index); + } + public void setActive(boolean active) { + AccelerometerDataJNI.setActive(m_index, active); + } + + public CallbackStore registerRangeCallback(NotifyCallback callback, boolean initialNotify) { + int uid = AccelerometerDataJNI.registerRangeCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, AccelerometerDataJNI::cancelRangeCallback); + } + public int getRange() { + return AccelerometerDataJNI.getRange(m_index); + } + public void setRange(int range) { + AccelerometerDataJNI.setRange(m_index, range); + } + + public CallbackStore registerXCallback(NotifyCallback callback, boolean initialNotify) { + int uid = AccelerometerDataJNI.registerXCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, AccelerometerDataJNI::cancelXCallback); + } + public double getX() { + return AccelerometerDataJNI.getX(m_index); + } + public void setX(double x) { + AccelerometerDataJNI.setX(m_index, x); + } + + public CallbackStore registerYCallback(NotifyCallback callback, boolean initialNotify) { + int uid = AccelerometerDataJNI.registerYCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, AccelerometerDataJNI::cancelYCallback); + } + public double getY() { + return AccelerometerDataJNI.getY(m_index); + } + public void setY(double y) { + AccelerometerDataJNI.setY(m_index, y); + } + + public CallbackStore registerZCallback(NotifyCallback callback, boolean initialNotify) { + int uid = AccelerometerDataJNI.registerZCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, AccelerometerDataJNI::cancelZCallback); + } + public double getZ() { + return AccelerometerDataJNI.getZ(m_index); + } + public void setZ(double z) { + AccelerometerDataJNI.setZ(m_index, z); + } + + public void resetData() { + AccelerometerDataJNI.resetData(m_index); + } +} diff --git a/hal/src/main/java/edu/wpi/first/wpilibj/sim/AnalogGyroSim.java b/hal/src/main/java/edu/wpi/first/wpilibj/sim/AnalogGyroSim.java new file mode 100644 index 0000000000..10f555b2d2 --- /dev/null +++ b/hal/src/main/java/edu/wpi/first/wpilibj/sim/AnalogGyroSim.java @@ -0,0 +1,55 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +package edu.wpi.first.wpilibj.sim; + +import edu.wpi.first.hal.sim.mockdata.AnalogGyroDataJNI; + +public class AnalogGyroSim { + private int m_index; + + public AnalogGyroSim(int index) { + m_index = index; + } + + public CallbackStore registerAngleCallback(NotifyCallback callback, boolean initialNotify) { + int uid = AnalogGyroDataJNI.registerAngleCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, AnalogGyroDataJNI::cancelAngleCallback); + } + public double getAngle() { + return AnalogGyroDataJNI.getAngle(m_index); + } + public void setAngle(double angle) { + AnalogGyroDataJNI.setAngle(m_index, angle); + } + + public CallbackStore registerRateCallback(NotifyCallback callback, boolean initialNotify) { + int uid = AnalogGyroDataJNI.registerRateCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, AnalogGyroDataJNI::cancelRateCallback); + } + public double getRate() { + return AnalogGyroDataJNI.getRate(m_index); + } + public void setRate(double rate) { + AnalogGyroDataJNI.setRate(m_index, rate); + } + + public CallbackStore registerInitializedCallback(NotifyCallback callback, boolean initialNotify) { + int uid = AnalogGyroDataJNI.registerInitializedCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, AnalogGyroDataJNI::cancelInitializedCallback); + } + public boolean getInitialized() { + return AnalogGyroDataJNI.getInitialized(m_index); + } + public void setInitialized(boolean initialized) { + AnalogGyroDataJNI.setInitialized(m_index, initialized); + } + + public void resetData() { + AnalogGyroDataJNI.resetData(m_index); + } +} diff --git a/hal/src/main/java/edu/wpi/first/wpilibj/sim/AnalogInSim.java b/hal/src/main/java/edu/wpi/first/wpilibj/sim/AnalogInSim.java new file mode 100644 index 0000000000..40135e9fcb --- /dev/null +++ b/hal/src/main/java/edu/wpi/first/wpilibj/sim/AnalogInSim.java @@ -0,0 +1,121 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +package edu.wpi.first.wpilibj.sim; + +import edu.wpi.first.hal.sim.mockdata.AnalogInDataJNI; + +public class AnalogInSim { + private int m_index; + + public AnalogInSim(int index) { + m_index = index; + } + + public CallbackStore registerInitializedCallback(NotifyCallback callback, boolean initialNotify) { + int uid = AnalogInDataJNI.registerInitializedCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, AnalogInDataJNI::cancelInitializedCallback); + } + public boolean getInitialized() { + return AnalogInDataJNI.getInitialized(m_index); + } + public void setInitialized(boolean initialized) { + AnalogInDataJNI.setInitialized(m_index, initialized); + } + + public CallbackStore registerAverageBitsCallback(NotifyCallback callback, boolean initialNotify) { + int uid = AnalogInDataJNI.registerAverageBitsCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, AnalogInDataJNI::cancelAverageBitsCallback); + } + public int getAverageBits() { + return AnalogInDataJNI.getAverageBits(m_index); + } + public void setAverageBits(int averageBits) { + AnalogInDataJNI.setAverageBits(m_index, averageBits); + } + + public CallbackStore registerOversampleBitsCallback(NotifyCallback callback, boolean initialNotify) { + int uid = AnalogInDataJNI.registerOversampleBitsCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, AnalogInDataJNI::cancelOversampleBitsCallback); + } + public int getOversampleBits() { + return AnalogInDataJNI.getOversampleBits(m_index); + } + public void setOversampleBits(int oversampleBits) { + AnalogInDataJNI.setOversampleBits(m_index, oversampleBits); + } + + public CallbackStore registerVoltageCallback(NotifyCallback callback, boolean initialNotify) { + int uid = AnalogInDataJNI.registerVoltageCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, AnalogInDataJNI::cancelVoltageCallback); + } + public double getVoltage() { + return AnalogInDataJNI.getVoltage(m_index); + } + public void setVoltage(double voltage) { + AnalogInDataJNI.setVoltage(m_index, voltage); + } + + public CallbackStore registerAccumulatorInitializedCallback(NotifyCallback callback, boolean initialNotify) { + int uid = AnalogInDataJNI.registerAccumulatorInitializedCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, AnalogInDataJNI::cancelAccumulatorInitializedCallback); + } + public boolean getAccumulatorInitialized() { + return AnalogInDataJNI.getAccumulatorInitialized(m_index); + } + public void setAccumulatorInitialized(boolean accumulatorInitialized) { + AnalogInDataJNI.setAccumulatorInitialized(m_index, accumulatorInitialized); + } + + public CallbackStore registerAccumulatorValueCallback(NotifyCallback callback, boolean initialNotify) { + int uid = AnalogInDataJNI.registerAccumulatorValueCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, AnalogInDataJNI::cancelAccumulatorValueCallback); + } + public long getAccumulatorValue() { + return AnalogInDataJNI.getAccumulatorValue(m_index); + } + public void setAccumulatorValue(long accumulatorValue) { + AnalogInDataJNI.setAccumulatorValue(m_index, accumulatorValue); + } + + public CallbackStore registerAccumulatorCountCallback(NotifyCallback callback, boolean initialNotify) { + int uid = AnalogInDataJNI.registerAccumulatorCountCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, AnalogInDataJNI::cancelAccumulatorCountCallback); + } + public long getAccumulatorCount() { + return AnalogInDataJNI.getAccumulatorCount(m_index); + } + public void setAccumulatorCount(long accumulatorCount) { + AnalogInDataJNI.setAccumulatorCount(m_index, accumulatorCount); + } + + public CallbackStore registerAccumulatorCenterCallback(NotifyCallback callback, boolean initialNotify) { + int uid = AnalogInDataJNI.registerAccumulatorCenterCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, AnalogInDataJNI::cancelAccumulatorCenterCallback); + } + public int getAccumulatorCenter() { + return AnalogInDataJNI.getAccumulatorCenter(m_index); + } + public void setAccumulatorCenter(int accumulatorCenter) { + AnalogInDataJNI.setAccumulatorCenter(m_index, accumulatorCenter); + } + + public CallbackStore registerAccumulatorDeadbandCallback(NotifyCallback callback, boolean initialNotify) { + int uid = AnalogInDataJNI.registerAccumulatorDeadbandCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, AnalogInDataJNI::cancelAccumulatorDeadbandCallback); + } + public int getAccumulatorDeadband() { + return AnalogInDataJNI.getAccumulatorDeadband(m_index); + } + public void setAccumulatorDeadband(int accumulatorDeadband) { + AnalogInDataJNI.setAccumulatorDeadband(m_index, accumulatorDeadband); + } + + public void resetData() { + AnalogInDataJNI.resetData(m_index); + } +} diff --git a/hal/src/main/java/edu/wpi/first/wpilibj/sim/AnalogOutSim.java b/hal/src/main/java/edu/wpi/first/wpilibj/sim/AnalogOutSim.java new file mode 100644 index 0000000000..643563e355 --- /dev/null +++ b/hal/src/main/java/edu/wpi/first/wpilibj/sim/AnalogOutSim.java @@ -0,0 +1,44 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +package edu.wpi.first.wpilibj.sim; + +import edu.wpi.first.hal.sim.mockdata.AnalogOutDataJNI; + +public class AnalogOutSim { + private int m_index; + + public AnalogOutSim(int index) { + m_index = index; + } + + public CallbackStore registerVoltageCallback(NotifyCallback callback, boolean initialNotify) { + int uid = AnalogOutDataJNI.registerVoltageCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, AnalogOutDataJNI::cancelVoltageCallback); + } + public double getVoltage() { + return AnalogOutDataJNI.getVoltage(m_index); + } + public void setVoltage(double voltage) { + AnalogOutDataJNI.setVoltage(m_index, voltage); + } + + public CallbackStore registerInitializedCallback(NotifyCallback callback, boolean initialNotify) { + int uid = AnalogOutDataJNI.registerInitializedCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, AnalogOutDataJNI::cancelInitializedCallback); + } + public boolean getInitialized() { + return AnalogOutDataJNI.getInitialized(m_index); + } + public void setInitialized(boolean initialized) { + AnalogOutDataJNI.setInitialized(m_index, initialized); + } + + public void resetData() { + AnalogOutDataJNI.resetData(m_index); + } +} diff --git a/hal/src/main/java/edu/wpi/first/wpilibj/sim/AnalogTriggerSim.java b/hal/src/main/java/edu/wpi/first/wpilibj/sim/AnalogTriggerSim.java new file mode 100644 index 0000000000..a4d5f9c448 --- /dev/null +++ b/hal/src/main/java/edu/wpi/first/wpilibj/sim/AnalogTriggerSim.java @@ -0,0 +1,55 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +package edu.wpi.first.wpilibj.sim; + +import edu.wpi.first.hal.sim.mockdata.AnalogTriggerDataJNI; + +public class AnalogTriggerSim { + private int m_index; + + public AnalogTriggerSim(int index) { + m_index = index; + } + + public CallbackStore registerInitializedCallback(NotifyCallback callback, boolean initialNotify) { + int uid = AnalogTriggerDataJNI.registerInitializedCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, AnalogTriggerDataJNI::cancelInitializedCallback); + } + public boolean getInitialized() { + return AnalogTriggerDataJNI.getInitialized(m_index); + } + public void setInitialized(boolean initialized) { + AnalogTriggerDataJNI.setInitialized(m_index, initialized); + } + + public CallbackStore registerTriggerLowerBoundCallback(NotifyCallback callback, boolean initialNotify) { + int uid = AnalogTriggerDataJNI.registerTriggerLowerBoundCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, AnalogTriggerDataJNI::cancelTriggerLowerBoundCallback); + } + public double getTriggerLowerBound() { + return AnalogTriggerDataJNI.getTriggerLowerBound(m_index); + } + public void setTriggerLowerBound(double triggerLowerBound) { + AnalogTriggerDataJNI.setTriggerLowerBound(m_index, triggerLowerBound); + } + + public CallbackStore registerTriggerUpperBoundCallback(NotifyCallback callback, boolean initialNotify) { + int uid = AnalogTriggerDataJNI.registerTriggerUpperBoundCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, AnalogTriggerDataJNI::cancelTriggerUpperBoundCallback); + } + public double getTriggerUpperBound() { + return AnalogTriggerDataJNI.getTriggerUpperBound(m_index); + } + public void setTriggerUpperBound(double triggerUpperBound) { + AnalogTriggerDataJNI.setTriggerUpperBound(m_index, triggerUpperBound); + } + + public void resetData() { + AnalogTriggerDataJNI.resetData(m_index); + } +} diff --git a/hal/src/main/java/edu/wpi/first/wpilibj/sim/BufferCallback.java b/hal/src/main/java/edu/wpi/first/wpilibj/sim/BufferCallback.java new file mode 100644 index 0000000000..3478aba362 --- /dev/null +++ b/hal/src/main/java/edu/wpi/first/wpilibj/sim/BufferCallback.java @@ -0,0 +1,12 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +package edu.wpi.first.wpilibj.sim; + +public interface BufferCallback { + void callback(String name, byte[] buffer, int count); +} diff --git a/hal/src/main/java/edu/wpi/first/wpilibj/sim/CallbackStore.java b/hal/src/main/java/edu/wpi/first/wpilibj/sim/CallbackStore.java new file mode 100644 index 0000000000..5e307cf138 --- /dev/null +++ b/hal/src/main/java/edu/wpi/first/wpilibj/sim/CallbackStore.java @@ -0,0 +1,83 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +package edu.wpi.first.wpilibj.sim; + +import java.io.Closeable; + +public class CallbackStore implements Closeable { + interface CancelCallbackFunc { + void cancel(int index, int uid); + } + + interface CancelCallbackChannelFunc { + void cancel(int index, int channel, int uid); + } + + interface CancelCallbackNoIndexFunc { + void cancel(int uid); + } + + public CallbackStore(int index, int uid, CancelCallbackFunc ccf) { + this.cancelType = normalCancel; + this.index = index; + this.uid = uid; + this.cancelCallback = ccf; + } + + public CallbackStore(int index, int channel, int uid, CancelCallbackChannelFunc ccf) { + this.cancelType = channelCancel; + this.index = index; + this.uid = uid; + this.channel = channel; + this.cancelCallbackChannel = ccf; + } + + public CallbackStore(int uid, CancelCallbackNoIndexFunc ccf) { + this.cancelType = noIndexCancel; + this.uid = uid; + this.cancelCallbackNoIndex = ccf; + } + + private int index; + private int channel; + private int uid; + private CancelCallbackFunc cancelCallback; + private CancelCallbackChannelFunc cancelCallbackChannel; + private CancelCallbackNoIndexFunc cancelCallbackNoIndex; + private static final int normalCancel = 0; + private static final int channelCancel = 1; + private static final int noIndexCancel = 2; + private int cancelType; + + @Override + public void close() { + switch (cancelType) { + case normalCancel: + cancelCallback.cancel(index, uid); + break; + case channelCancel: + cancelCallbackChannel.cancel(index, channel, uid); + break; + case noIndexCancel: + cancelCallbackNoIndex.cancel(uid); + break; + } + cancelType = -1; + } + + @Override + protected void finalize() throws Throwable { + try { + if (cancelType >= 0) { + close(); // close open files + } + } finally { + super.finalize(); + } + } +} diff --git a/hal/src/main/java/edu/wpi/first/wpilibj/sim/ConstBufferCallback.java b/hal/src/main/java/edu/wpi/first/wpilibj/sim/ConstBufferCallback.java new file mode 100644 index 0000000000..2a942b1d77 --- /dev/null +++ b/hal/src/main/java/edu/wpi/first/wpilibj/sim/ConstBufferCallback.java @@ -0,0 +1,12 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +package edu.wpi.first.wpilibj.sim; + +public interface ConstBufferCallback { + void callback(String name, byte[] buffer, int count); +} diff --git a/hal/src/main/java/edu/wpi/first/wpilibj/sim/DIOSim.java b/hal/src/main/java/edu/wpi/first/wpilibj/sim/DIOSim.java new file mode 100644 index 0000000000..8817e07a8f --- /dev/null +++ b/hal/src/main/java/edu/wpi/first/wpilibj/sim/DIOSim.java @@ -0,0 +1,77 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +package edu.wpi.first.wpilibj.sim; + +import edu.wpi.first.hal.sim.mockdata.DIODataJNI; + +public class DIOSim { + private int m_index; + + public DIOSim(int index) { + m_index = index; + } + + public CallbackStore registerInitializedCallback(NotifyCallback callback, boolean initialNotify) { + int uid = DIODataJNI.registerInitializedCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, DIODataJNI::cancelInitializedCallback); + } + public boolean getInitialized() { + return DIODataJNI.getInitialized(m_index); + } + public void setInitialized(boolean initialized) { + DIODataJNI.setInitialized(m_index, initialized); + } + + public CallbackStore registerValueCallback(NotifyCallback callback, boolean initialNotify) { + int uid = DIODataJNI.registerValueCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, DIODataJNI::cancelValueCallback); + } + public boolean getValue() { + return DIODataJNI.getValue(m_index); + } + public void setValue(boolean value) { + DIODataJNI.setValue(m_index, value); + } + + public CallbackStore registerPulseLengthCallback(NotifyCallback callback, boolean initialNotify) { + int uid = DIODataJNI.registerPulseLengthCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, DIODataJNI::cancelPulseLengthCallback); + } + public double getPulseLength() { + return DIODataJNI.getPulseLength(m_index); + } + public void setPulseLength(double pulseLength) { + DIODataJNI.setPulseLength(m_index, pulseLength); + } + + public CallbackStore registerIsInputCallback(NotifyCallback callback, boolean initialNotify) { + int uid = DIODataJNI.registerIsInputCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, DIODataJNI::cancelIsInputCallback); + } + public boolean getIsInput() { + return DIODataJNI.getIsInput(m_index); + } + public void setIsInput(boolean isInput) { + DIODataJNI.setIsInput(m_index, isInput); + } + + public CallbackStore registerFilterIndexCallback(NotifyCallback callback, boolean initialNotify) { + int uid = DIODataJNI.registerFilterIndexCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, DIODataJNI::cancelFilterIndexCallback); + } + public int getFilterIndex() { + return DIODataJNI.getFilterIndex(m_index); + } + public void setFilterIndex(int filterIndex) { + DIODataJNI.setFilterIndex(m_index, filterIndex); + } + + public void resetData() { + DIODataJNI.resetData(m_index); + } +} diff --git a/hal/src/main/java/edu/wpi/first/wpilibj/sim/DigitalPWMSim.java b/hal/src/main/java/edu/wpi/first/wpilibj/sim/DigitalPWMSim.java new file mode 100644 index 0000000000..0ebd1a55a3 --- /dev/null +++ b/hal/src/main/java/edu/wpi/first/wpilibj/sim/DigitalPWMSim.java @@ -0,0 +1,55 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +package edu.wpi.first.wpilibj.sim; + +import edu.wpi.first.hal.sim.mockdata.DigitalPWMDataJNI; + +public class DigitalPWMSim { + private int m_index; + + public DigitalPWMSim(int index) { + m_index = index; + } + + public CallbackStore registerInitializedCallback(NotifyCallback callback, boolean initialNotify) { + int uid = DigitalPWMDataJNI.registerInitializedCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, DigitalPWMDataJNI::cancelInitializedCallback); + } + public boolean getInitialized() { + return DigitalPWMDataJNI.getInitialized(m_index); + } + public void setInitialized(boolean initialized) { + DigitalPWMDataJNI.setInitialized(m_index, initialized); + } + + public CallbackStore registerDutyCycleCallback(NotifyCallback callback, boolean initialNotify) { + int uid = DigitalPWMDataJNI.registerDutyCycleCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, DigitalPWMDataJNI::cancelDutyCycleCallback); + } + public double getDutyCycle() { + return DigitalPWMDataJNI.getDutyCycle(m_index); + } + public void setDutyCycle(double dutyCycle) { + DigitalPWMDataJNI.setDutyCycle(m_index, dutyCycle); + } + + public CallbackStore registerPinCallback(NotifyCallback callback, boolean initialNotify) { + int uid = DigitalPWMDataJNI.registerPinCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, DigitalPWMDataJNI::cancelPinCallback); + } + public int getPin() { + return DigitalPWMDataJNI.getPin(m_index); + } + public void setPin(int pin) { + DigitalPWMDataJNI.setPin(m_index, pin); + } + + public void resetData() { + DigitalPWMDataJNI.resetData(m_index); + } +} diff --git a/hal/src/main/java/edu/wpi/first/wpilibj/sim/DriverStationSim.java b/hal/src/main/java/edu/wpi/first/wpilibj/sim/DriverStationSim.java new file mode 100644 index 0000000000..64a3b05b2b --- /dev/null +++ b/hal/src/main/java/edu/wpi/first/wpilibj/sim/DriverStationSim.java @@ -0,0 +1,82 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +package edu.wpi.first.wpilibj.sim; + +import edu.wpi.first.hal.sim.mockdata.DriverStationDataJNI; + +public class DriverStationSim { + public CallbackStore registerEnabledCallback(NotifyCallback callback, boolean initialNotify) { + int uid = DriverStationDataJNI.registerEnabledCallback(callback, initialNotify); + return new CallbackStore(uid, DriverStationDataJNI::cancelEnabledCallback); + } + public boolean getEnabled() { + return DriverStationDataJNI.getEnabled(); + } + public void setEnabled(boolean enabled) { + DriverStationDataJNI.setEnabled(enabled); + } + + public CallbackStore registerAutonomousCallback(NotifyCallback callback, boolean initialNotify) { + int uid = DriverStationDataJNI.registerAutonomousCallback(callback, initialNotify); + return new CallbackStore(uid, DriverStationDataJNI::cancelAutonomousCallback); + } + public boolean getAutonomous() { + return DriverStationDataJNI.getAutonomous(); + } + public void setAutonomous(boolean autonomous) { + DriverStationDataJNI.setAutonomous(autonomous); + } + + public CallbackStore registerTestCallback(NotifyCallback callback, boolean initialNotify) { + int uid = DriverStationDataJNI.registerTestCallback(callback, initialNotify); + return new CallbackStore(uid, DriverStationDataJNI::cancelTestCallback); + } + public boolean getTest() { + return DriverStationDataJNI.getTest(); + } + public void setTest(boolean test) { + DriverStationDataJNI.setTest(test); + } + + public CallbackStore registerEStopCallback(NotifyCallback callback, boolean initialNotify) { + int uid = DriverStationDataJNI.registerEStopCallback(callback, initialNotify); + return new CallbackStore(uid, DriverStationDataJNI::cancelEStopCallback); + } + public boolean getEStop() { + return DriverStationDataJNI.getEStop(); + } + public void setEStop(boolean eStop) { + DriverStationDataJNI.setEStop(eStop); + } + + public CallbackStore registerFmsAttachedCallback(NotifyCallback callback, boolean initialNotify) { + int uid = DriverStationDataJNI.registerFmsAttachedCallback(callback, initialNotify); + return new CallbackStore(uid, DriverStationDataJNI::cancelFmsAttachedCallback); + } + public boolean getFmsAttached() { + return DriverStationDataJNI.getFmsAttached(); + } + public void setFmsAttached(boolean fmsAttached) { + DriverStationDataJNI.setFmsAttached(fmsAttached); + } + + public CallbackStore registerDsAttachedCallback(NotifyCallback callback, boolean initialNotify) { + int uid = DriverStationDataJNI.registerDsAttachedCallback(callback, initialNotify); + return new CallbackStore(uid, DriverStationDataJNI::cancelDsAttachedCallback); + } + public boolean getDsAttached() { + return DriverStationDataJNI.getDsAttached(); + } + public void setDsAttached(boolean dsAttached) { + DriverStationDataJNI.setDsAttached(dsAttached); + } + + public void resetData() { + DriverStationDataJNI.resetData(); + } +} diff --git a/hal/src/main/java/edu/wpi/first/wpilibj/sim/EncoderSim.java b/hal/src/main/java/edu/wpi/first/wpilibj/sim/EncoderSim.java new file mode 100644 index 0000000000..d9b6aef877 --- /dev/null +++ b/hal/src/main/java/edu/wpi/first/wpilibj/sim/EncoderSim.java @@ -0,0 +1,110 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +package edu.wpi.first.wpilibj.sim; + +import edu.wpi.first.hal.sim.mockdata.EncoderDataJNI; + +public class EncoderSim { + private int m_index; + + public EncoderSim(int index) { + m_index = index; + } + + public CallbackStore registerInitializedCallback(NotifyCallback callback, boolean initialNotify) { + int uid = EncoderDataJNI.registerInitializedCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, EncoderDataJNI::cancelInitializedCallback); + } + public boolean getInitialized() { + return EncoderDataJNI.getInitialized(m_index); + } + public void setInitialized(boolean initialized) { + EncoderDataJNI.setInitialized(m_index, initialized); + } + + public CallbackStore registerCountCallback(NotifyCallback callback, boolean initialNotify) { + int uid = EncoderDataJNI.registerCountCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, EncoderDataJNI::cancelCountCallback); + } + public int getCount() { + return EncoderDataJNI.getCount(m_index); + } + public void setCount(int count) { + EncoderDataJNI.setCount(m_index, count); + } + + public CallbackStore registerPeriodCallback(NotifyCallback callback, boolean initialNotify) { + int uid = EncoderDataJNI.registerPeriodCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, EncoderDataJNI::cancelPeriodCallback); + } + public double getPeriod() { + return EncoderDataJNI.getPeriod(m_index); + } + public void setPeriod(double period) { + EncoderDataJNI.setPeriod(m_index, period); + } + + public CallbackStore registerResetCallback(NotifyCallback callback, boolean initialNotify) { + int uid = EncoderDataJNI.registerResetCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, EncoderDataJNI::cancelResetCallback); + } + public boolean getReset() { + return EncoderDataJNI.getReset(m_index); + } + public void setReset(boolean reset) { + EncoderDataJNI.setReset(m_index, reset); + } + + public CallbackStore registerMaxPeriodCallback(NotifyCallback callback, boolean initialNotify) { + int uid = EncoderDataJNI.registerMaxPeriodCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, EncoderDataJNI::cancelMaxPeriodCallback); + } + public double getMaxPeriod() { + return EncoderDataJNI.getMaxPeriod(m_index); + } + public void setMaxPeriod(double maxPeriod) { + EncoderDataJNI.setMaxPeriod(m_index, maxPeriod); + } + + public CallbackStore registerDirectionCallback(NotifyCallback callback, boolean initialNotify) { + int uid = EncoderDataJNI.registerDirectionCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, EncoderDataJNI::cancelDirectionCallback); + } + public boolean getDirection() { + return EncoderDataJNI.getDirection(m_index); + } + public void setDirection(boolean direction) { + EncoderDataJNI.setDirection(m_index, direction); + } + + public CallbackStore registerReverseDirectionCallback(NotifyCallback callback, boolean initialNotify) { + int uid = EncoderDataJNI.registerReverseDirectionCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, EncoderDataJNI::cancelReverseDirectionCallback); + } + public boolean getReverseDirection() { + return EncoderDataJNI.getReverseDirection(m_index); + } + public void setReverseDirection(boolean reverseDirection) { + EncoderDataJNI.setReverseDirection(m_index, reverseDirection); + } + + public CallbackStore registerSamplesToAverageCallback(NotifyCallback callback, boolean initialNotify) { + int uid = EncoderDataJNI.registerSamplesToAverageCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, EncoderDataJNI::cancelSamplesToAverageCallback); + } + public int getSamplesToAverage() { + return EncoderDataJNI.getSamplesToAverage(m_index); + } + public void setSamplesToAverage(int samplesToAverage) { + EncoderDataJNI.setSamplesToAverage(m_index, samplesToAverage); + } + + public void resetData() { + EncoderDataJNI.resetData(m_index); + } +} diff --git a/hal/src/main/java/edu/wpi/first/wpilibj/sim/I2CSim.java b/hal/src/main/java/edu/wpi/first/wpilibj/sim/I2CSim.java new file mode 100644 index 0000000000..a88dfe78a7 --- /dev/null +++ b/hal/src/main/java/edu/wpi/first/wpilibj/sim/I2CSim.java @@ -0,0 +1,43 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +package edu.wpi.first.wpilibj.sim; + +import edu.wpi.first.hal.sim.mockdata.I2CDataJNI; + +public class I2CSim { + private int m_index; + + public I2CSim(int index) { + m_index = index; + } + + public CallbackStore registerInitializedCallback(NotifyCallback callback, boolean initialNotify) { + int uid = I2CDataJNI.registerInitializedCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, I2CDataJNI::cancelInitializedCallback); + } + public boolean getInitialized() { + return I2CDataJNI.getInitialized(m_index); + } + public void setInitialized(boolean initialized) { + I2CDataJNI.setInitialized(m_index, initialized); + } + + public CallbackStore registerReadCallback(BufferCallback callback) { + int uid = I2CDataJNI.registerReadCallback(m_index, callback); + return new CallbackStore(m_index, uid, I2CDataJNI::cancelReadCallback); + } + + public CallbackStore registerWriteCallback(ConstBufferCallback callback) { + int uid = I2CDataJNI.registerWriteCallback(m_index, callback); + return new CallbackStore(m_index, uid, I2CDataJNI::cancelWriteCallback); + } + + public void resetData() { + I2CDataJNI.resetData(m_index); + } +} diff --git a/hal/src/main/java/edu/wpi/first/wpilibj/sim/NotifyCallback.java b/hal/src/main/java/edu/wpi/first/wpilibj/sim/NotifyCallback.java new file mode 100644 index 0000000000..ab1150808f --- /dev/null +++ b/hal/src/main/java/edu/wpi/first/wpilibj/sim/NotifyCallback.java @@ -0,0 +1,34 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +package edu.wpi.first.wpilibj.sim; + +public interface NotifyCallback { + void callback(String name, SimValue value); + + default void callbackNative(String name, int type, long value1, double value2) { + switch(type) { + case 0x01: + callback(name, SimValue.makeBoolean(value1 != 0)); + break; + case 0x02: + callback(name, SimValue.makeDouble(value2)); + break; + case 0x16: + callback(name, SimValue.makeEnum((int)value1)); + break; + case 0x32: + callback(name, SimValue.makeInt((int)value1)); + break; + case 0x64: + callback(name, SimValue.makeLong(value1)); + break; + default: + callback(name, SimValue.makeUnassigned()); + } + } +} diff --git a/hal/src/main/java/edu/wpi/first/wpilibj/sim/PCMSim.java b/hal/src/main/java/edu/wpi/first/wpilibj/sim/PCMSim.java new file mode 100644 index 0000000000..7582dd00fd --- /dev/null +++ b/hal/src/main/java/edu/wpi/first/wpilibj/sim/PCMSim.java @@ -0,0 +1,99 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +package edu.wpi.first.wpilibj.sim; + +import edu.wpi.first.hal.sim.mockdata.PCMDataJNI; + +public class PCMSim { + private int m_index; + + public PCMSim(int index) { + m_index = index; + } + + public CallbackStore registerSolenoidInitializedCallback(int channel, NotifyCallback callback, boolean initialNotify) { + int uid = PCMDataJNI.registerSolenoidInitializedCallback(m_index, channel, callback, initialNotify); + return new CallbackStore(m_index, channel, uid, PCMDataJNI::cancelSolenoidInitializedCallback); + } + public boolean getSolenoidInitialized(int channel) { + return PCMDataJNI.getSolenoidInitialized(m_index, channel); + } + public void setSolenoidInitialized(int channel, boolean solenoidInitialized) { + PCMDataJNI.setSolenoidInitialized(m_index, channel, solenoidInitialized); + } + + public CallbackStore registerSolenoidOutputCallback(int channel, NotifyCallback callback, boolean initialNotify) { + int uid = PCMDataJNI.registerSolenoidOutputCallback(m_index, channel, callback, initialNotify); + return new CallbackStore(m_index, channel, uid, PCMDataJNI::cancelSolenoidOutputCallback); + } + public boolean getSolenoidOutput(int channel) { + return PCMDataJNI.getSolenoidOutput(m_index, channel); + } + public void setSolenoidOutput(int channel, boolean solenoidOutput) { + PCMDataJNI.setSolenoidOutput(m_index, channel, solenoidOutput); + } + + public CallbackStore registerCompressorInitializedCallback(NotifyCallback callback, boolean initialNotify) { + int uid = PCMDataJNI.registerCompressorInitializedCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, PCMDataJNI::cancelCompressorInitializedCallback); + } + public boolean getCompressorInitialized() { + return PCMDataJNI.getCompressorInitialized(m_index); + } + public void setCompressorInitialized(boolean compressorInitialized) { + PCMDataJNI.setCompressorInitialized(m_index, compressorInitialized); + } + + public CallbackStore registerCompressorOnCallback(NotifyCallback callback, boolean initialNotify) { + int uid = PCMDataJNI.registerCompressorOnCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, PCMDataJNI::cancelCompressorOnCallback); + } + public boolean getCompressorOn() { + return PCMDataJNI.getCompressorOn(m_index); + } + public void setCompressorOn(boolean compressorOn) { + PCMDataJNI.setCompressorOn(m_index, compressorOn); + } + + public CallbackStore registerClosedLoopEnabledCallback(NotifyCallback callback, boolean initialNotify) { + int uid = PCMDataJNI.registerClosedLoopEnabledCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, PCMDataJNI::cancelClosedLoopEnabledCallback); + } + public boolean getClosedLoopEnabled() { + return PCMDataJNI.getClosedLoopEnabled(m_index); + } + public void setClosedLoopEnabled(boolean closedLoopEnabled) { + PCMDataJNI.setClosedLoopEnabled(m_index, closedLoopEnabled); + } + + public CallbackStore registerPressureSwitchCallback(NotifyCallback callback, boolean initialNotify) { + int uid = PCMDataJNI.registerPressureSwitchCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, PCMDataJNI::cancelPressureSwitchCallback); + } + public boolean getPressureSwitch() { + return PCMDataJNI.getPressureSwitch(m_index); + } + public void setPressureSwitch(boolean pressureSwitch) { + PCMDataJNI.setPressureSwitch(m_index, pressureSwitch); + } + + public CallbackStore registerCompressorCurrentCallback(NotifyCallback callback, boolean initialNotify) { + int uid = PCMDataJNI.registerCompressorCurrentCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, PCMDataJNI::cancelCompressorCurrentCallback); + } + public double getCompressorCurrent() { + return PCMDataJNI.getCompressorCurrent(m_index); + } + public void setCompressorCurrent(double compressorCurrent) { + PCMDataJNI.setCompressorCurrent(m_index, compressorCurrent); + } + + public void resetData() { + PCMDataJNI.resetData(m_index); + } +} diff --git a/hal/src/main/java/edu/wpi/first/wpilibj/sim/PDPSim.java b/hal/src/main/java/edu/wpi/first/wpilibj/sim/PDPSim.java new file mode 100644 index 0000000000..3cdda0f5f2 --- /dev/null +++ b/hal/src/main/java/edu/wpi/first/wpilibj/sim/PDPSim.java @@ -0,0 +1,66 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +package edu.wpi.first.wpilibj.sim; + +import edu.wpi.first.hal.sim.mockdata.PDPDataJNI; + +public class PDPSim { + private int m_index; + + public PDPSim(int index) { + m_index = index; + } + + public CallbackStore registerInitializedCallback(NotifyCallback callback, boolean initialNotify) { + int uid = PDPDataJNI.registerInitializedCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, PDPDataJNI::cancelInitializedCallback); + } + public boolean getInitialized() { + return PDPDataJNI.getInitialized(m_index); + } + public void setInitialized(boolean initialized) { + PDPDataJNI.setInitialized(m_index, initialized); + } + + public CallbackStore registerTemperatureCallback(NotifyCallback callback, boolean initialNotify) { + int uid = PDPDataJNI.registerTemperatureCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, PDPDataJNI::cancelTemperatureCallback); + } + public double getTemperature() { + return PDPDataJNI.getTemperature(m_index); + } + public void setTemperature(double temperature) { + PDPDataJNI.setTemperature(m_index, temperature); + } + + public CallbackStore registerVoltageCallback(NotifyCallback callback, boolean initialNotify) { + int uid = PDPDataJNI.registerVoltageCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, PDPDataJNI::cancelVoltageCallback); + } + public double getVoltage() { + return PDPDataJNI.getVoltage(m_index); + } + public void setVoltage(double voltage) { + PDPDataJNI.setVoltage(m_index, voltage); + } + + public CallbackStore registerCurrentCallback(int channel, NotifyCallback callback, boolean initialNotify) { + int uid = PDPDataJNI.registerCurrentCallback(m_index, channel, callback, initialNotify); + return new CallbackStore(m_index, channel, uid, PDPDataJNI::cancelCurrentCallback); + } + public double getCurrent(int channel) { + return PDPDataJNI.getCurrent(channel, m_index); + } + public void setCurrent(int channel, double current) { + PDPDataJNI.setCurrent(m_index, channel, current); + } + + public void resetData() { + PDPDataJNI.resetData(m_index); + } +} diff --git a/hal/src/main/java/edu/wpi/first/wpilibj/sim/PWMSim.java b/hal/src/main/java/edu/wpi/first/wpilibj/sim/PWMSim.java new file mode 100644 index 0000000000..82711bfe5a --- /dev/null +++ b/hal/src/main/java/edu/wpi/first/wpilibj/sim/PWMSim.java @@ -0,0 +1,88 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +package edu.wpi.first.wpilibj.sim; + +import edu.wpi.first.hal.sim.mockdata.PWMDataJNI; + +public class PWMSim { + private int m_index; + + public PWMSim(int index) { + m_index = index; + } + + public CallbackStore registerInitializedCallback(NotifyCallback callback, boolean initialNotify) { + int uid = PWMDataJNI.registerInitializedCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, PWMDataJNI::cancelInitializedCallback); + } + public boolean getInitialized() { + return PWMDataJNI.getInitialized(m_index); + } + public void setInitialized(boolean initialized) { + PWMDataJNI.setInitialized(m_index, initialized); + } + + public CallbackStore registerRawValueCallback(NotifyCallback callback, boolean initialNotify) { + int uid = PWMDataJNI.registerRawValueCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, PWMDataJNI::cancelRawValueCallback); + } + public int getRawValue() { + return PWMDataJNI.getRawValue(m_index); + } + public void setRawValue(int rawValue) { + PWMDataJNI.setRawValue(m_index, rawValue); + } + + public CallbackStore registerSpeedCallback(NotifyCallback callback, boolean initialNotify) { + int uid = PWMDataJNI.registerSpeedCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, PWMDataJNI::cancelSpeedCallback); + } + public double getSpeed() { + return PWMDataJNI.getSpeed(m_index); + } + public void setSpeed(double speed) { + PWMDataJNI.setSpeed(m_index, speed); + } + + public CallbackStore registerPositionCallback(NotifyCallback callback, boolean initialNotify) { + int uid = PWMDataJNI.registerPositionCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, PWMDataJNI::cancelPositionCallback); + } + public double getPosition() { + return PWMDataJNI.getPosition(m_index); + } + public void setPosition(double position) { + PWMDataJNI.setPosition(m_index, position); + } + + public CallbackStore registerPeriodScaleCallback(NotifyCallback callback, boolean initialNotify) { + int uid = PWMDataJNI.registerPeriodScaleCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, PWMDataJNI::cancelPeriodScaleCallback); + } + public int getPeriodScale() { + return PWMDataJNI.getPeriodScale(m_index); + } + public void setPeriodScale(int periodScale) { + PWMDataJNI.setPeriodScale(m_index, periodScale); + } + + public CallbackStore registerZeroLatchCallback(NotifyCallback callback, boolean initialNotify) { + int uid = PWMDataJNI.registerZeroLatchCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, PWMDataJNI::cancelZeroLatchCallback); + } + public boolean getZeroLatch() { + return PWMDataJNI.getZeroLatch(m_index); + } + public void setZeroLatch(boolean zeroLatch) { + PWMDataJNI.setZeroLatch(m_index, zeroLatch); + } + + public void resetData() { + PWMDataJNI.resetData(m_index); + } +} diff --git a/hal/src/main/java/edu/wpi/first/wpilibj/sim/RelaySim.java b/hal/src/main/java/edu/wpi/first/wpilibj/sim/RelaySim.java new file mode 100644 index 0000000000..d897876063 --- /dev/null +++ b/hal/src/main/java/edu/wpi/first/wpilibj/sim/RelaySim.java @@ -0,0 +1,66 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +package edu.wpi.first.wpilibj.sim; + +import edu.wpi.first.hal.sim.mockdata.RelayDataJNI; + +public class RelaySim { + private int m_index; + + public RelaySim(int index) { + m_index = index; + } + + public CallbackStore registerInitializedForwardCallback(NotifyCallback callback, boolean initialNotify) { + int uid = RelayDataJNI.registerInitializedForwardCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, RelayDataJNI::cancelInitializedForwardCallback); + } + public boolean getInitializedForward() { + return RelayDataJNI.getInitializedForward(m_index); + } + public void setInitializedForward(boolean initializedForward) { + RelayDataJNI.setInitializedForward(m_index, initializedForward); + } + + public CallbackStore registerInitializedReverseCallback(NotifyCallback callback, boolean initialNotify) { + int uid = RelayDataJNI.registerInitializedReverseCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, RelayDataJNI::cancelInitializedReverseCallback); + } + public boolean getInitializedReverse() { + return RelayDataJNI.getInitializedReverse(m_index); + } + public void setInitializedReverse(boolean initializedReverse) { + RelayDataJNI.setInitializedReverse(m_index, initializedReverse); + } + + public CallbackStore registerForwardCallback(NotifyCallback callback, boolean initialNotify) { + int uid = RelayDataJNI.registerForwardCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, RelayDataJNI::cancelForwardCallback); + } + public boolean getForward() { + return RelayDataJNI.getForward(m_index); + } + public void setForward(boolean forward) { + RelayDataJNI.setForward(m_index, forward); + } + + public CallbackStore registerReverseCallback(NotifyCallback callback, boolean initialNotify) { + int uid = RelayDataJNI.registerReverseCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, RelayDataJNI::cancelReverseCallback); + } + public boolean getReverse() { + return RelayDataJNI.getReverse(m_index); + } + public void setReverse(boolean reverse) { + RelayDataJNI.setReverse(m_index, reverse); + } + + public void resetData() { + RelayDataJNI.resetData(m_index); + } +} diff --git a/hal/src/main/java/edu/wpi/first/wpilibj/sim/RoboRioSim.java b/hal/src/main/java/edu/wpi/first/wpilibj/sim/RoboRioSim.java new file mode 100644 index 0000000000..125407d1ee --- /dev/null +++ b/hal/src/main/java/edu/wpi/first/wpilibj/sim/RoboRioSim.java @@ -0,0 +1,187 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +package edu.wpi.first.wpilibj.sim; + +import edu.wpi.first.hal.sim.mockdata.RoboRioDataJNI; + +public class RoboRioSim { + private int m_index; + + public RoboRioSim(int index) { + m_index = index; + } + + public CallbackStore registerFPGAButtonCallback(NotifyCallback callback, boolean initialNotify) { + int uid = RoboRioDataJNI.registerFPGAButtonCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, RoboRioDataJNI::cancelFPGAButtonCallback); + } + public boolean getFPGAButton() { + return RoboRioDataJNI.getFPGAButton(m_index); + } + public void setFPGAButton(boolean fPGAButton) { + RoboRioDataJNI.setFPGAButton(m_index, fPGAButton); + } + + public CallbackStore registerVInVoltageCallback(NotifyCallback callback, boolean initialNotify) { + int uid = RoboRioDataJNI.registerVInVoltageCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, RoboRioDataJNI::cancelVInVoltageCallback); + } + public double getVInVoltage() { + return RoboRioDataJNI.getVInVoltage(m_index); + } + public void setVInVoltage(double vInVoltage) { + RoboRioDataJNI.setVInVoltage(m_index, vInVoltage); + } + + public CallbackStore registerVInCurrentCallback(NotifyCallback callback, boolean initialNotify) { + int uid = RoboRioDataJNI.registerVInCurrentCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, RoboRioDataJNI::cancelVInCurrentCallback); + } + public double getVInCurrent() { + return RoboRioDataJNI.getVInCurrent(m_index); + } + public void setVInCurrent(double vInCurrent) { + RoboRioDataJNI.setVInCurrent(m_index, vInCurrent); + } + + public CallbackStore registerUserVoltage6VCallback(NotifyCallback callback, boolean initialNotify) { + int uid = RoboRioDataJNI.registerUserVoltage6VCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, RoboRioDataJNI::cancelUserVoltage6VCallback); + } + public double getUserVoltage6V() { + return RoboRioDataJNI.getUserVoltage6V(m_index); + } + public void setUserVoltage6V(double userVoltage6V) { + RoboRioDataJNI.setUserVoltage6V(m_index, userVoltage6V); + } + + public CallbackStore registerUserCurrent6VCallback(NotifyCallback callback, boolean initialNotify) { + int uid = RoboRioDataJNI.registerUserCurrent6VCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, RoboRioDataJNI::cancelUserCurrent6VCallback); + } + public double getUserCurrent6V() { + return RoboRioDataJNI.getUserCurrent6V(m_index); + } + public void setUserCurrent6V(double userCurrent6V) { + RoboRioDataJNI.setUserCurrent6V(m_index, userCurrent6V); + } + + public CallbackStore registerUserActive6VCallback(NotifyCallback callback, boolean initialNotify) { + int uid = RoboRioDataJNI.registerUserActive6VCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, RoboRioDataJNI::cancelUserActive6VCallback); + } + public boolean getUserActive6V() { + return RoboRioDataJNI.getUserActive6V(m_index); + } + public void setUserActive6V(boolean userActive6V) { + RoboRioDataJNI.setUserActive6V(m_index, userActive6V); + } + + public CallbackStore registerUserVoltage5VCallback(NotifyCallback callback, boolean initialNotify) { + int uid = RoboRioDataJNI.registerUserVoltage5VCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, RoboRioDataJNI::cancelUserVoltage5VCallback); + } + public double getUserVoltage5V() { + return RoboRioDataJNI.getUserVoltage5V(m_index); + } + public void setUserVoltage5V(double userVoltage5V) { + RoboRioDataJNI.setUserVoltage5V(m_index, userVoltage5V); + } + + public CallbackStore registerUserCurrent5VCallback(NotifyCallback callback, boolean initialNotify) { + int uid = RoboRioDataJNI.registerUserCurrent5VCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, RoboRioDataJNI::cancelUserCurrent5VCallback); + } + public double getUserCurrent5V() { + return RoboRioDataJNI.getUserCurrent5V(m_index); + } + public void setUserCurrent5V(double userCurrent5V) { + RoboRioDataJNI.setUserCurrent5V(m_index, userCurrent5V); + } + + public CallbackStore registerUserActive5VCallback(NotifyCallback callback, boolean initialNotify) { + int uid = RoboRioDataJNI.registerUserActive5VCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, RoboRioDataJNI::cancelUserActive5VCallback); + } + public boolean getUserActive5V() { + return RoboRioDataJNI.getUserActive5V(m_index); + } + public void setUserActive5V(boolean userActive5V) { + RoboRioDataJNI.setUserActive5V(m_index, userActive5V); + } + + public CallbackStore registerUserVoltage3V3Callback(NotifyCallback callback, boolean initialNotify) { + int uid = RoboRioDataJNI.registerUserVoltage3V3Callback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, RoboRioDataJNI::cancelUserVoltage3V3Callback); + } + public double getUserVoltage3V3() { + return RoboRioDataJNI.getUserVoltage3V3(m_index); + } + public void setUserVoltage3V3(double userVoltage3V3) { + RoboRioDataJNI.setUserVoltage3V3(m_index, userVoltage3V3); + } + + public CallbackStore registerUserCurrent3V3Callback(NotifyCallback callback, boolean initialNotify) { + int uid = RoboRioDataJNI.registerUserCurrent3V3Callback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, RoboRioDataJNI::cancelUserCurrent3V3Callback); + } + public double getUserCurrent3V3() { + return RoboRioDataJNI.getUserCurrent3V3(m_index); + } + public void setUserCurrent3V3(double userCurrent3V3) { + RoboRioDataJNI.setUserCurrent3V3(m_index, userCurrent3V3); + } + + public CallbackStore registerUserActive3V3Callback(NotifyCallback callback, boolean initialNotify) { + int uid = RoboRioDataJNI.registerUserActive3V3Callback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, RoboRioDataJNI::cancelUserActive3V3Callback); + } + public boolean getUserActive3V3() { + return RoboRioDataJNI.getUserActive3V3(m_index); + } + public void setUserActive3V3(boolean userActive3V3) { + RoboRioDataJNI.setUserActive3V3(m_index, userActive3V3); + } + + public CallbackStore registerUserFaults6VCallback(NotifyCallback callback, boolean initialNotify) { + int uid = RoboRioDataJNI.registerUserFaults6VCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, RoboRioDataJNI::cancelUserFaults6VCallback); + } + public int getUserFaults6V() { + return RoboRioDataJNI.getUserFaults6V(m_index); + } + public void setUserFaults6V(int userFaults6V) { + RoboRioDataJNI.setUserFaults6V(m_index, userFaults6V); + } + + public CallbackStore registerUserFaults5VCallback(NotifyCallback callback, boolean initialNotify) { + int uid = RoboRioDataJNI.registerUserFaults5VCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, RoboRioDataJNI::cancelUserFaults5VCallback); + } + public int getUserFaults5V() { + return RoboRioDataJNI.getUserFaults5V(m_index); + } + public void setUserFaults5V(int userFaults5V) { + RoboRioDataJNI.setUserFaults5V(m_index, userFaults5V); + } + + public CallbackStore registerUserFaults3V3Callback(NotifyCallback callback, boolean initialNotify) { + int uid = RoboRioDataJNI.registerUserFaults3V3Callback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, RoboRioDataJNI::cancelUserFaults3V3Callback); + } + public int getUserFaults3V3() { + return RoboRioDataJNI.getUserFaults3V3(m_index); + } + public void setUserFaults3V3(int userFaults3V3) { + RoboRioDataJNI.setUserFaults3V3(m_index, userFaults3V3); + } + + public void resetData() { + RoboRioDataJNI.resetData(m_index); + } +} diff --git a/hal/src/main/java/edu/wpi/first/wpilibj/sim/SPIAccelerometerSim.java b/hal/src/main/java/edu/wpi/first/wpilibj/sim/SPIAccelerometerSim.java new file mode 100644 index 0000000000..c0f4681c68 --- /dev/null +++ b/hal/src/main/java/edu/wpi/first/wpilibj/sim/SPIAccelerometerSim.java @@ -0,0 +1,77 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +package edu.wpi.first.wpilibj.sim; + +import edu.wpi.first.hal.sim.mockdata.SPIAccelerometerDataJNI; + +public class SPIAccelerometerSim { + private int m_index; + + public SPIAccelerometerSim(int index) { + m_index = index; + } + + public CallbackStore registerActiveCallback(NotifyCallback callback, boolean initialNotify) { + int uid = SPIAccelerometerDataJNI.registerActiveCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, SPIAccelerometerDataJNI::cancelActiveCallback); + } + public boolean getActive() { + return SPIAccelerometerDataJNI.getActive(m_index); + } + public void setActive(boolean active) { + SPIAccelerometerDataJNI.setActive(m_index, active); + } + + public CallbackStore registerRangeCallback(NotifyCallback callback, boolean initialNotify) { + int uid = SPIAccelerometerDataJNI.registerRangeCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, SPIAccelerometerDataJNI::cancelRangeCallback); + } + public int getRange() { + return SPIAccelerometerDataJNI.getRange(m_index); + } + public void setRange(int range) { + SPIAccelerometerDataJNI.setRange(m_index, range); + } + + public CallbackStore registerXCallback(NotifyCallback callback, boolean initialNotify) { + int uid = SPIAccelerometerDataJNI.registerXCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, SPIAccelerometerDataJNI::cancelXCallback); + } + public double getX() { + return SPIAccelerometerDataJNI.getX(m_index); + } + public void setX(double x) { + SPIAccelerometerDataJNI.setX(m_index, x); + } + + public CallbackStore registerYCallback(NotifyCallback callback, boolean initialNotify) { + int uid = SPIAccelerometerDataJNI.registerYCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, SPIAccelerometerDataJNI::cancelYCallback); + } + public double getY() { + return SPIAccelerometerDataJNI.getY(m_index); + } + public void setY(double y) { + SPIAccelerometerDataJNI.setY(m_index, y); + } + + public CallbackStore registerZCallback(NotifyCallback callback, boolean initialNotify) { + int uid = SPIAccelerometerDataJNI.registerZCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, SPIAccelerometerDataJNI::cancelZCallback); + } + public double getZ() { + return SPIAccelerometerDataJNI.getZ(m_index); + } + public void setZ(double z) { + SPIAccelerometerDataJNI.setZ(m_index, z); + } + + public void resetData() { + SPIAccelerometerDataJNI.resetData(m_index); + } +} diff --git a/hal/src/main/java/edu/wpi/first/wpilibj/sim/SPISim.java b/hal/src/main/java/edu/wpi/first/wpilibj/sim/SPISim.java new file mode 100644 index 0000000000..0a5c19fdc3 --- /dev/null +++ b/hal/src/main/java/edu/wpi/first/wpilibj/sim/SPISim.java @@ -0,0 +1,48 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +package edu.wpi.first.wpilibj.sim; + +import edu.wpi.first.hal.sim.mockdata.SPIDataJNI; + +public class SPISim { + private int m_index; + + public SPISim(int index) { + m_index = index; + } + + public CallbackStore registerInitializedCallback(NotifyCallback callback, boolean initialNotify) { + int uid = SPIDataJNI.registerInitializedCallback(m_index, callback, initialNotify); + return new CallbackStore(m_index, uid, SPIDataJNI::cancelInitializedCallback); + } + public boolean getInitialized() { + return SPIDataJNI.getInitialized(m_index); + } + public void setInitialized(boolean initialized) { + SPIDataJNI.setInitialized(m_index, initialized); + } + + public CallbackStore registerReadCallback(BufferCallback callback) { + int uid = SPIDataJNI.registerReadCallback(m_index, callback); + return new CallbackStore(m_index, uid, SPIDataJNI::cancelReadCallback); + } + + public CallbackStore registerWriteCallback(ConstBufferCallback callback) { + int uid = SPIDataJNI.registerWriteCallback(m_index, callback); + return new CallbackStore(m_index, uid, SPIDataJNI::cancelWriteCallback); + } + + public CallbackStore registerReadAutoReceiveBufferCallback(SpiReadAutoReceiveBufferCallback callback) { + int uid = SPIDataJNI.registerReadAutoReceiveBufferCallback(m_index, callback); + return new CallbackStore(m_index, uid, SPIDataJNI::cancelReadAutoReceiveBufferCallback); + } + + public void resetData() { + SPIDataJNI.resetData(m_index); + } +} diff --git a/hal/src/main/java/edu/wpi/first/wpilibj/sim/SimHooks.java b/hal/src/main/java/edu/wpi/first/wpilibj/sim/SimHooks.java new file mode 100644 index 0000000000..ac6b7aff23 --- /dev/null +++ b/hal/src/main/java/edu/wpi/first/wpilibj/sim/SimHooks.java @@ -0,0 +1,27 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +package edu.wpi.first.wpilibj.sim; + +import edu.wpi.first.hal.sim.mockdata.SimulatorJNI; + +public class SimHooks { + private SimHooks() { + } + + public static void waitForProgramStart() { + SimulatorJNI.waitForProgramStart(); + } + + public static void setProgramStarted() { + SimulatorJNI.setProgramStarted(); + } + + public static void restartTiming() { + SimulatorJNI.restartTiming(); + } +} diff --git a/hal/src/main/java/edu/wpi/first/wpilibj/sim/SimValue.java b/hal/src/main/java/edu/wpi/first/wpilibj/sim/SimValue.java new file mode 100644 index 0000000000..aa3550dc7b --- /dev/null +++ b/hal/src/main/java/edu/wpi/first/wpilibj/sim/SimValue.java @@ -0,0 +1,66 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +package edu.wpi.first.wpilibj.sim; + +public class SimValue { + private boolean v_boolean; + private long v_long; + private double v_double; + + private SimValue(boolean b) { + v_boolean = b; + } + + private SimValue(double v) { + v_double = v; + } + + private SimValue(long v) { + v_long = v; + } + + private SimValue() { + + } + + public boolean getBoolean() { + return v_boolean; + } + + public long getLong() { + return v_long; + } + + public double getDouble() { + return v_double; + } + + public static SimValue makeBoolean(boolean value) { + return new SimValue(value); + } + + public static SimValue makeEnum(int value) { + return new SimValue(value); + } + + public static SimValue makeInt(int value) { + return new SimValue(value); + } + + public static SimValue makeLong(long value) { + return new SimValue(value); + } + + public static SimValue makeDouble(double value) { + return new SimValue(value); + } + + public static SimValue makeUnassigned() { + return new SimValue(); + } +} diff --git a/hal/src/main/java/edu/wpi/first/wpilibj/sim/SpiReadAutoReceiveBufferCallback.java b/hal/src/main/java/edu/wpi/first/wpilibj/sim/SpiReadAutoReceiveBufferCallback.java new file mode 100644 index 0000000000..59b58dbc87 --- /dev/null +++ b/hal/src/main/java/edu/wpi/first/wpilibj/sim/SpiReadAutoReceiveBufferCallback.java @@ -0,0 +1,12 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +package edu.wpi.first.wpilibj.sim; + +public interface SpiReadAutoReceiveBufferCallback { + int callback(String name, byte[] buffer, int numToRead); +} diff --git a/hal/src/main/native/include/Simulation/AccelerometerSim.h b/hal/src/main/native/include/Simulation/AccelerometerSim.h new file mode 100644 index 0000000000..9a8b273197 --- /dev/null +++ b/hal/src/main/native/include/Simulation/AccelerometerSim.h @@ -0,0 +1,92 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#pragma once + +#ifndef __FRC_ROBORIO__ + +#include +#include + +#include "CallbackStore.h" +#include "MockData/AccelerometerData.h" + +namespace frc { +namespace sim { +class AccelerometerSim { + public: + explicit AccelerometerSim(int index) { m_index = index; } + + std::unique_ptr RegisterActiveCallback(NotifyCallback callback, + bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelAccelerometerActiveCallback); + store->SetUid(HALSIM_RegisterAccelerometerActiveCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + bool GetActive() { return HALSIM_GetAccelerometerActive(m_index); } + void SetActive(bool active) { + HALSIM_SetAccelerometerActive(m_index, active); + } + + std::unique_ptr RegisterRangeCallback(NotifyCallback callback, + bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelAccelerometerRangeCallback); + store->SetUid(HALSIM_RegisterAccelerometerRangeCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + HAL_AccelerometerRange GetRange() { + return HALSIM_GetAccelerometerRange(m_index); + } + void SetRange(HAL_AccelerometerRange range) { + HALSIM_SetAccelerometerRange(m_index, range); + } + + std::unique_ptr RegisterXCallback(NotifyCallback callback, + bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelAccelerometerXCallback); + store->SetUid(HALSIM_RegisterAccelerometerXCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + double GetX() { return HALSIM_GetAccelerometerX(m_index); } + void SetX(double x) { HALSIM_SetAccelerometerX(m_index, x); } + + std::unique_ptr RegisterYCallback(NotifyCallback callback, + bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelAccelerometerYCallback); + store->SetUid(HALSIM_RegisterAccelerometerYCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + double GetY() { return HALSIM_GetAccelerometerY(m_index); } + void SetY(double y) { HALSIM_SetAccelerometerY(m_index, y); } + + std::unique_ptr RegisterZCallback(NotifyCallback callback, + bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelAccelerometerZCallback); + store->SetUid(HALSIM_RegisterAccelerometerZCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + double GetZ() { return HALSIM_GetAccelerometerZ(m_index); } + void SetZ(double z) { HALSIM_SetAccelerometerZ(m_index, z); } + + void ResetData() { HALSIM_ResetAccelerometerData(m_index); } + + private: + int m_index; +}; +} // namespace sim +} // namespace frc +#endif // __FRC_ROBORIO__ diff --git a/hal/src/main/native/include/Simulation/AnalogGyroSim.h b/hal/src/main/native/include/Simulation/AnalogGyroSim.h new file mode 100644 index 0000000000..7d4cff02f5 --- /dev/null +++ b/hal/src/main/native/include/Simulation/AnalogGyroSim.h @@ -0,0 +1,66 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#pragma once + +#ifndef __FRC_ROBORIO__ + +#include +#include + +#include "CallbackStore.h" +#include "MockData/AnalogGyroData.h" + +namespace frc { +namespace sim { +class AnalogGyroSim { + public: + explicit AnalogGyroSim(int index) { m_index = index; } + + std::unique_ptr RegisterAngleCallback(NotifyCallback callback, + bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelAnalogGyroAngleCallback); + store->SetUid(HALSIM_RegisterAnalogGyroAngleCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + double GetAngle() { return HALSIM_GetAnalogGyroAngle(m_index); } + void SetAngle(double angle) { HALSIM_SetAnalogGyroAngle(m_index, angle); } + + std::unique_ptr RegisterRateCallback(NotifyCallback callback, + bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelAnalogGyroRateCallback); + store->SetUid(HALSIM_RegisterAnalogGyroRateCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + double GetRate() { return HALSIM_GetAnalogGyroRate(m_index); } + void SetRate(double rate) { HALSIM_SetAnalogGyroRate(m_index, rate); } + + std::unique_ptr RegisterInitializedCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelAnalogGyroInitializedCallback); + store->SetUid(HALSIM_RegisterAnalogGyroInitializedCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + bool GetInitialized() { return HALSIM_GetAnalogGyroInitialized(m_index); } + void SetInitialized(bool initialized) { + HALSIM_SetAnalogGyroInitialized(m_index, initialized); + } + + void ResetData() { HALSIM_ResetAnalogGyroData(m_index); } + + private: + int m_index; +}; +} // namespace sim +} // namespace frc +#endif // __FRC_ROBORIO__ diff --git a/hal/src/main/native/include/Simulation/AnalogInSim.h b/hal/src/main/native/include/Simulation/AnalogInSim.h new file mode 100644 index 0000000000..815fc48e36 --- /dev/null +++ b/hal/src/main/native/include/Simulation/AnalogInSim.h @@ -0,0 +1,160 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#pragma once + +#ifndef __FRC_ROBORIO__ + +#include +#include + +#include "CallbackStore.h" +#include "MockData/AnalogInData.h" + +namespace frc { +namespace sim { +class AnalogInSim { + public: + explicit AnalogInSim(int index) { m_index = index; } + + std::unique_ptr RegisterInitializedCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelAnalogInInitializedCallback); + store->SetUid(HALSIM_RegisterAnalogInInitializedCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + bool GetInitialized() { return HALSIM_GetAnalogInInitialized(m_index); } + void SetInitialized(bool initialized) { + HALSIM_SetAnalogInInitialized(m_index, initialized); + } + + std::unique_ptr RegisterAverageBitsCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelAnalogInAverageBitsCallback); + store->SetUid(HALSIM_RegisterAnalogInAverageBitsCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + int GetAverageBits() { return HALSIM_GetAnalogInAverageBits(m_index); } + void SetAverageBits(int averageBits) { + HALSIM_SetAnalogInAverageBits(m_index, averageBits); + } + + std::unique_ptr RegisterOversampleBitsCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelAnalogInOversampleBitsCallback); + store->SetUid(HALSIM_RegisterAnalogInOversampleBitsCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + int GetOversampleBits() { return HALSIM_GetAnalogInOversampleBits(m_index); } + void SetOversampleBits(int oversampleBits) { + HALSIM_SetAnalogInOversampleBits(m_index, oversampleBits); + } + + std::unique_ptr RegisterVoltageCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelAnalogInVoltageCallback); + store->SetUid(HALSIM_RegisterAnalogInVoltageCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + double GetVoltage() { return HALSIM_GetAnalogInVoltage(m_index); } + void SetVoltage(double voltage) { + HALSIM_SetAnalogInVoltage(m_index, voltage); + } + + std::unique_ptr RegisterAccumulatorInitializedCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, + &HALSIM_CancelAnalogInAccumulatorInitializedCallback); + store->SetUid(HALSIM_RegisterAnalogInAccumulatorInitializedCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + bool GetAccumulatorInitialized() { + return HALSIM_GetAnalogInAccumulatorInitialized(m_index); + } + void SetAccumulatorInitialized(bool accumulatorInitialized) { + HALSIM_SetAnalogInAccumulatorInitialized(m_index, accumulatorInitialized); + } + + std::unique_ptr RegisterAccumulatorValueCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelAnalogInAccumulatorValueCallback); + store->SetUid(HALSIM_RegisterAnalogInAccumulatorValueCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + int64_t GetAccumulatorValue() { + return HALSIM_GetAnalogInAccumulatorValue(m_index); + } + void SetAccumulatorValue(int64_t accumulatorValue) { + HALSIM_SetAnalogInAccumulatorValue(m_index, accumulatorValue); + } + + std::unique_ptr RegisterAccumulatorCountCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelAnalogInAccumulatorCountCallback); + store->SetUid(HALSIM_RegisterAnalogInAccumulatorCountCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + int64_t GetAccumulatorCount() { + return HALSIM_GetAnalogInAccumulatorCount(m_index); + } + void SetAccumulatorCount(int64_t accumulatorCount) { + HALSIM_SetAnalogInAccumulatorCount(m_index, accumulatorCount); + } + + std::unique_ptr RegisterAccumulatorCenterCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelAnalogInAccumulatorCenterCallback); + store->SetUid(HALSIM_RegisterAnalogInAccumulatorCenterCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + int GetAccumulatorCenter() { + return HALSIM_GetAnalogInAccumulatorCenter(m_index); + } + void SetAccumulatorCenter(int accumulatorCenter) { + HALSIM_SetAnalogInAccumulatorCenter(m_index, accumulatorCenter); + } + + std::unique_ptr RegisterAccumulatorDeadbandCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, + &HALSIM_CancelAnalogInAccumulatorDeadbandCallback); + store->SetUid(HALSIM_RegisterAnalogInAccumulatorDeadbandCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + int GetAccumulatorDeadband() { + return HALSIM_GetAnalogInAccumulatorDeadband(m_index); + } + void SetAccumulatorDeadband(int accumulatorDeadband) { + HALSIM_SetAnalogInAccumulatorDeadband(m_index, accumulatorDeadband); + } + + void ResetData() { HALSIM_ResetAnalogInData(m_index); } + + private: + int m_index; +}; +} // namespace sim +} // namespace frc +#endif // __FRC_ROBORIO__ diff --git a/hal/src/main/native/include/Simulation/AnalogOutSim.h b/hal/src/main/native/include/Simulation/AnalogOutSim.h new file mode 100644 index 0000000000..ce19f8469c --- /dev/null +++ b/hal/src/main/native/include/Simulation/AnalogOutSim.h @@ -0,0 +1,57 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#pragma once + +#ifndef __FRC_ROBORIO__ + +#include +#include + +#include "CallbackStore.h" +#include "MockData/AnalogOutData.h" + +namespace frc { +namespace sim { +class AnalogOutSim { + public: + explicit AnalogOutSim(int index) { m_index = index; } + + std::unique_ptr RegisterVoltageCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelAnalogOutVoltageCallback); + store->SetUid(HALSIM_RegisterAnalogOutVoltageCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + double GetVoltage() { return HALSIM_GetAnalogOutVoltage(m_index); } + void SetVoltage(double voltage) { + HALSIM_SetAnalogOutVoltage(m_index, voltage); + } + + std::unique_ptr RegisterInitializedCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelAnalogOutInitializedCallback); + store->SetUid(HALSIM_RegisterAnalogOutInitializedCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + bool GetInitialized() { return HALSIM_GetAnalogOutInitialized(m_index); } + void SetInitialized(bool initialized) { + HALSIM_SetAnalogOutInitialized(m_index, initialized); + } + + void ResetData() { HALSIM_ResetAnalogOutData(m_index); } + + private: + int m_index; +}; +} // namespace sim +} // namespace frc +#endif // __FRC_ROBORIO__ diff --git a/hal/src/main/native/include/Simulation/AnalogTriggerSim.h b/hal/src/main/native/include/Simulation/AnalogTriggerSim.h new file mode 100644 index 0000000000..03d21e2352 --- /dev/null +++ b/hal/src/main/native/include/Simulation/AnalogTriggerSim.h @@ -0,0 +1,76 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#pragma once + +#ifndef __FRC_ROBORIO__ + +#include +#include + +#include "CallbackStore.h" +#include "MockData/AnalogTriggerData.h" + +namespace frc { +namespace sim { +class AnalogTriggerSim { + public: + explicit AnalogTriggerSim(int index) { m_index = index; } + + std::unique_ptr RegisterInitializedCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelAnalogTriggerInitializedCallback); + store->SetUid(HALSIM_RegisterAnalogTriggerInitializedCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + bool GetInitialized() { return HALSIM_GetAnalogTriggerInitialized(m_index); } + void SetInitialized(bool initialized) { + HALSIM_SetAnalogTriggerInitialized(m_index, initialized); + } + + std::unique_ptr RegisterTriggerLowerBoundCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, + &HALSIM_CancelAnalogTriggerTriggerLowerBoundCallback); + store->SetUid(HALSIM_RegisterAnalogTriggerTriggerLowerBoundCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + double GetTriggerLowerBound() { + return HALSIM_GetAnalogTriggerTriggerLowerBound(m_index); + } + void SetTriggerLowerBound(double triggerLowerBound) { + HALSIM_SetAnalogTriggerTriggerLowerBound(m_index, triggerLowerBound); + } + + std::unique_ptr RegisterTriggerUpperBoundCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, + &HALSIM_CancelAnalogTriggerTriggerUpperBoundCallback); + store->SetUid(HALSIM_RegisterAnalogTriggerTriggerUpperBoundCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + double GetTriggerUpperBound() { + return HALSIM_GetAnalogTriggerTriggerUpperBound(m_index); + } + void SetTriggerUpperBound(double triggerUpperBound) { + HALSIM_SetAnalogTriggerTriggerUpperBound(m_index, triggerUpperBound); + } + + void ResetData() { HALSIM_ResetAnalogTriggerData(m_index); } + + private: + int m_index; +}; +} // namespace sim +} // namespace frc +#endif // __FRC_ROBORIO__ diff --git a/hal/src/main/native/include/Simulation/CallbackStore.h b/hal/src/main/native/include/Simulation/CallbackStore.h new file mode 100644 index 0000000000..b5f66b8920 --- /dev/null +++ b/hal/src/main/native/include/Simulation/CallbackStore.h @@ -0,0 +1,90 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#pragma once + +#ifndef __FRC_ROBORIO__ + +#include + +#include + +#include "MockData/HAL_Value.h" + +namespace frc { +namespace sim { + +using NotifyCallback = std::function; +typedef void (*CancelCallbackFunc)(int32_t index, int32_t uid); +typedef void (*CancelCallbackNoIndexFunc)(int32_t uid); +typedef void (*CancelCallbackChannelFunc)(int32_t index, int32_t channel, + int32_t uid); + +void CallbackStoreThunk(const char* name, void* param, const HAL_Value* value); + +class CallbackStore { + public: + CallbackStore(int32_t i, NotifyCallback cb, CancelCallbackNoIndexFunc ccf) { + index = i; + callback = cb; + this->ccnif = ccf; + cancelType = NoIndex; + } + CallbackStore(int32_t i, int32_t u, NotifyCallback cb, + CancelCallbackFunc ccf) { + index = i; + uid = u; + callback = cb; + this->ccf = ccf; + cancelType = Normal; + } + CallbackStore(int32_t i, int32_t c, int32_t u, NotifyCallback cb, + CancelCallbackChannelFunc ccf) { + index = i; + channel = c; + uid = u; + callback = cb; + this->cccf = ccf; + cancelType = Channel; + } + ~CallbackStore() { + switch (cancelType) { + case Normal: + ccf(index, uid); + break; + case Channel: + cccf(index, channel, uid); + break; + case NoIndex: + ccnif(uid); + break; + } + } + + void SetUid(int32_t uid) { this->uid = uid; } + + friend void CallbackStoreThunk(const char* name, void* param, + const HAL_Value* value); + + private: + int32_t index; + int32_t channel; + int32_t uid; + + NotifyCallback callback; + union { + CancelCallbackFunc ccf; + CancelCallbackChannelFunc cccf; + CancelCallbackNoIndexFunc ccnif; + }; + enum CancelType { Normal, Channel, NoIndex }; + CancelType cancelType; +}; +} // namespace sim +} // namespace frc + +#endif diff --git a/hal/src/main/native/include/Simulation/DIOSim.h b/hal/src/main/native/include/Simulation/DIOSim.h new file mode 100644 index 0000000000..f9e347fcd4 --- /dev/null +++ b/hal/src/main/native/include/Simulation/DIOSim.h @@ -0,0 +1,92 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#pragma once + +#ifndef __FRC_ROBORIO__ + +#include +#include + +#include "CallbackStore.h" +#include "MockData/DIOData.h" + +namespace frc { +namespace sim { +class DIOSim { + public: + explicit DIOSim(int index) { m_index = index; } + + std::unique_ptr RegisterInitializedCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelDIOInitializedCallback); + store->SetUid(HALSIM_RegisterDIOInitializedCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + bool GetInitialized() { return HALSIM_GetDIOInitialized(m_index); } + void SetInitialized(bool initialized) { + HALSIM_SetDIOInitialized(m_index, initialized); + } + + std::unique_ptr RegisterValueCallback(NotifyCallback callback, + bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelDIOValueCallback); + store->SetUid(HALSIM_RegisterDIOValueCallback(m_index, &CallbackStoreThunk, + store.get(), initialNotify)); + return std::move(store); + } + bool GetValue() { return HALSIM_GetDIOValue(m_index); } + void SetValue(bool value) { HALSIM_SetDIOValue(m_index, value); } + + std::unique_ptr RegisterPulseLengthCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelDIOPulseLengthCallback); + store->SetUid(HALSIM_RegisterDIOPulseLengthCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + double GetPulseLength() { return HALSIM_GetDIOPulseLength(m_index); } + void SetPulseLength(double pulseLength) { + HALSIM_SetDIOPulseLength(m_index, pulseLength); + } + + std::unique_ptr RegisterIsInputCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelDIOIsInputCallback); + store->SetUid(HALSIM_RegisterDIOIsInputCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + bool GetIsInput() { return HALSIM_GetDIOIsInput(m_index); } + void SetIsInput(bool isInput) { HALSIM_SetDIOIsInput(m_index, isInput); } + + std::unique_ptr RegisterFilterIndexCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelDIOFilterIndexCallback); + store->SetUid(HALSIM_RegisterDIOFilterIndexCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + int GetFilterIndex() { return HALSIM_GetDIOFilterIndex(m_index); } + void SetFilterIndex(int filterIndex) { + HALSIM_SetDIOFilterIndex(m_index, filterIndex); + } + + void ResetData() { HALSIM_ResetDIOData(m_index); } + + private: + int m_index; +}; +} // namespace sim +} // namespace frc +#endif // __FRC_ROBORIO__ diff --git a/hal/src/main/native/include/Simulation/DigitalPWMSim.h b/hal/src/main/native/include/Simulation/DigitalPWMSim.h new file mode 100644 index 0000000000..85c0a0a6aa --- /dev/null +++ b/hal/src/main/native/include/Simulation/DigitalPWMSim.h @@ -0,0 +1,68 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#pragma once + +#ifndef __FRC_ROBORIO__ + +#include +#include + +#include "CallbackStore.h" +#include "MockData/DigitalPWMData.h" + +namespace frc { +namespace sim { +class DigitalPWMSim { + public: + explicit DigitalPWMSim(int index) { m_index = index; } + + std::unique_ptr RegisterInitializedCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelDigitalPWMInitializedCallback); + store->SetUid(HALSIM_RegisterDigitalPWMInitializedCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + bool GetInitialized() { return HALSIM_GetDigitalPWMInitialized(m_index); } + void SetInitialized(bool initialized) { + HALSIM_SetDigitalPWMInitialized(m_index, initialized); + } + + std::unique_ptr RegisterDutyCycleCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelDigitalPWMDutyCycleCallback); + store->SetUid(HALSIM_RegisterDigitalPWMDutyCycleCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + double GetDutyCycle() { return HALSIM_GetDigitalPWMDutyCycle(m_index); } + void SetDutyCycle(double dutyCycle) { + HALSIM_SetDigitalPWMDutyCycle(m_index, dutyCycle); + } + + std::unique_ptr RegisterPinCallback(NotifyCallback callback, + bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelDigitalPWMPinCallback); + store->SetUid(HALSIM_RegisterDigitalPWMPinCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + int GetPin() { return HALSIM_GetDigitalPWMPin(m_index); } + void SetPin(int pin) { HALSIM_SetDigitalPWMPin(m_index, pin); } + + void ResetData() { HALSIM_ResetDigitalPWMData(m_index); } + + private: + int m_index; +}; +} // namespace sim +} // namespace frc +#endif // __FRC_ROBORIO__ diff --git a/hal/src/main/native/include/Simulation/DriverStationSim.h b/hal/src/main/native/include/Simulation/DriverStationSim.h new file mode 100644 index 0000000000..aea5099049 --- /dev/null +++ b/hal/src/main/native/include/Simulation/DriverStationSim.h @@ -0,0 +1,98 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#pragma once + +#ifndef __FRC_ROBORIO__ + +#include +#include + +#include "CallbackStore.h" +#include "MockData/DriverStationData.h" + +namespace frc { +namespace sim { +class DriverStationSim { + public: + std::unique_ptr RegisterEnabledCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + -1, callback, &HALSIM_CancelDriverStationEnabledCallback); + store->SetUid(HALSIM_RegisterDriverStationEnabledCallback( + &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + bool GetEnabled() { return HALSIM_GetDriverStationEnabled(); } + void SetEnabled(bool enabled) { HALSIM_SetDriverStationEnabled(enabled); } + + std::unique_ptr RegisterAutonomousCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + -1, callback, &HALSIM_CancelDriverStationAutonomousCallback); + store->SetUid(HALSIM_RegisterDriverStationAutonomousCallback( + &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + bool GetAutonomous() { return HALSIM_GetDriverStationAutonomous(); } + void SetAutonomous(bool autonomous) { + HALSIM_SetDriverStationAutonomous(autonomous); + } + + std::unique_ptr RegisterTestCallback(NotifyCallback callback, + bool initialNotify) { + auto store = std::make_unique( + -1, callback, &HALSIM_CancelDriverStationTestCallback); + store->SetUid(HALSIM_RegisterDriverStationTestCallback( + &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + bool GetTest() { return HALSIM_GetDriverStationTest(); } + void SetTest(bool test) { HALSIM_SetDriverStationTest(test); } + + std::unique_ptr RegisterEStopCallback(NotifyCallback callback, + bool initialNotify) { + auto store = std::make_unique( + -1, callback, &HALSIM_CancelDriverStationEStopCallback); + store->SetUid(HALSIM_RegisterDriverStationEStopCallback( + &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + bool GetEStop() { return HALSIM_GetDriverStationEStop(); } + void SetEStop(bool eStop) { HALSIM_SetDriverStationEStop(eStop); } + + std::unique_ptr RegisterFmsAttachedCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + -1, callback, &HALSIM_CancelDriverStationFmsAttachedCallback); + store->SetUid(HALSIM_RegisterDriverStationFmsAttachedCallback( + &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + bool GetFmsAttached() { return HALSIM_GetDriverStationFmsAttached(); } + void SetFmsAttached(bool fmsAttached) { + HALSIM_SetDriverStationFmsAttached(fmsAttached); + } + + std::unique_ptr RegisterDsAttachedCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + -1, callback, &HALSIM_CancelDriverStationDsAttachedCallback); + store->SetUid(HALSIM_RegisterDriverStationDsAttachedCallback( + &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + bool GetDsAttached() { return HALSIM_GetDriverStationDsAttached(); } + void SetDsAttached(bool dsAttached) { + HALSIM_SetDriverStationDsAttached(dsAttached); + } + + void ResetData() { HALSIM_ResetDriverStationData(); } +}; +} // namespace sim +} // namespace frc +#endif // __FRC_ROBORIO__ diff --git a/hal/src/main/native/include/Simulation/EncoderSim.h b/hal/src/main/native/include/Simulation/EncoderSim.h new file mode 100644 index 0000000000..bbfee3146c --- /dev/null +++ b/hal/src/main/native/include/Simulation/EncoderSim.h @@ -0,0 +1,133 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#pragma once + +#ifndef __FRC_ROBORIO__ + +#include +#include + +#include "CallbackStore.h" +#include "MockData/EncoderData.h" + +namespace frc { +namespace sim { +class EncoderSim { + public: + explicit EncoderSim(int index) { m_index = index; } + + std::unique_ptr RegisterInitializedCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelEncoderInitializedCallback); + store->SetUid(HALSIM_RegisterEncoderInitializedCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + bool GetInitialized() { return HALSIM_GetEncoderInitialized(m_index); } + void SetInitialized(bool initialized) { + HALSIM_SetEncoderInitialized(m_index, initialized); + } + + std::unique_ptr RegisterCountCallback(NotifyCallback callback, + bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelEncoderCountCallback); + store->SetUid(HALSIM_RegisterEncoderCountCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + int GetCount() { return HALSIM_GetEncoderCount(m_index); } + void SetCount(int count) { HALSIM_SetEncoderCount(m_index, count); } + + std::unique_ptr RegisterPeriodCallback(NotifyCallback callback, + bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelEncoderPeriodCallback); + store->SetUid(HALSIM_RegisterEncoderPeriodCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + double GetPeriod() { return HALSIM_GetEncoderPeriod(m_index); } + void SetPeriod(double period) { HALSIM_SetEncoderPeriod(m_index, period); } + + std::unique_ptr RegisterResetCallback(NotifyCallback callback, + bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelEncoderResetCallback); + store->SetUid(HALSIM_RegisterEncoderResetCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + bool GetReset() { return HALSIM_GetEncoderReset(m_index); } + void SetReset(bool reset) { HALSIM_SetEncoderReset(m_index, reset); } + + std::unique_ptr RegisterMaxPeriodCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelEncoderMaxPeriodCallback); + store->SetUid(HALSIM_RegisterEncoderMaxPeriodCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + double GetMaxPeriod() { return HALSIM_GetEncoderMaxPeriod(m_index); } + void SetMaxPeriod(double maxPeriod) { + HALSIM_SetEncoderMaxPeriod(m_index, maxPeriod); + } + + std::unique_ptr RegisterDirectionCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelEncoderDirectionCallback); + store->SetUid(HALSIM_RegisterEncoderDirectionCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + bool GetDirection() { return HALSIM_GetEncoderDirection(m_index); } + void SetDirection(bool direction) { + HALSIM_SetEncoderDirection(m_index, direction); + } + + std::unique_ptr RegisterReverseDirectionCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelEncoderReverseDirectionCallback); + store->SetUid(HALSIM_RegisterEncoderReverseDirectionCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + bool GetReverseDirection() { + return HALSIM_GetEncoderReverseDirection(m_index); + } + void SetReverseDirection(bool reverseDirection) { + HALSIM_SetEncoderReverseDirection(m_index, reverseDirection); + } + + std::unique_ptr RegisterSamplesToAverageCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelEncoderSamplesToAverageCallback); + store->SetUid(HALSIM_RegisterEncoderSamplesToAverageCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + int GetSamplesToAverage() { + return HALSIM_GetEncoderSamplesToAverage(m_index); + } + void SetSamplesToAverage(int samplesToAverage) { + HALSIM_SetEncoderSamplesToAverage(m_index, samplesToAverage); + } + + void ResetData() { HALSIM_ResetEncoderData(m_index); } + + private: + int m_index; +}; +} // namespace sim +} // namespace frc +#endif // __FRC_ROBORIO__ diff --git a/hal/src/main/native/include/Simulation/PCMSim.h b/hal/src/main/native/include/Simulation/PCMSim.h new file mode 100644 index 0000000000..30516ad48f --- /dev/null +++ b/hal/src/main/native/include/Simulation/PCMSim.h @@ -0,0 +1,134 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#pragma once + +#ifndef __FRC_ROBORIO__ + +#include +#include + +#include "CallbackStore.h" +#include "MockData/PCMData.h" + +namespace frc { +namespace sim { +class PCMSim { + public: + explicit PCMSim(int index) { m_index = index; } + + std::unique_ptr RegisterSolenoidInitializedCallback( + int channel, NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, channel, -1, callback, + &HALSIM_CancelPCMSolenoidInitializedCallback); + store->SetUid(HALSIM_RegisterPCMSolenoidInitializedCallback( + m_index, channel, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + bool GetSolenoidInitialized(int channel) { + return HALSIM_GetPCMSolenoidInitialized(m_index, channel); + } + void SetSolenoidInitialized(int channel, bool solenoidInitialized) { + HALSIM_SetPCMSolenoidInitialized(m_index, channel, solenoidInitialized); + } + + std::unique_ptr RegisterSolenoidOutputCallback( + int channel, NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, channel, -1, callback, + &HALSIM_CancelPCMSolenoidOutputCallback); + store->SetUid(HALSIM_RegisterPCMSolenoidOutputCallback( + m_index, channel, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + bool GetSolenoidOutput(int channel) { + return HALSIM_GetPCMSolenoidOutput(m_index, channel); + } + void SetSolenoidOutput(int channel, bool solenoidOutput) { + HALSIM_SetPCMSolenoidOutput(m_index, channel, solenoidOutput); + } + + std::unique_ptr RegisterCompressorInitializedCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelPCMCompressorInitializedCallback); + store->SetUid(HALSIM_RegisterPCMCompressorInitializedCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + bool GetCompressorInitialized() { + return HALSIM_GetPCMCompressorInitialized(m_index); + } + void SetCompressorInitialized(bool compressorInitialized) { + HALSIM_SetPCMCompressorInitialized(m_index, compressorInitialized); + } + + std::unique_ptr RegisterCompressorOnCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelPCMCompressorOnCallback); + store->SetUid(HALSIM_RegisterPCMCompressorOnCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + bool GetCompressorOn() { return HALSIM_GetPCMCompressorOn(m_index); } + void SetCompressorOn(bool compressorOn) { + HALSIM_SetPCMCompressorOn(m_index, compressorOn); + } + + std::unique_ptr RegisterClosedLoopEnabledCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelPCMClosedLoopEnabledCallback); + store->SetUid(HALSIM_RegisterPCMClosedLoopEnabledCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + bool GetClosedLoopEnabled() { + return HALSIM_GetPCMClosedLoopEnabled(m_index); + } + void SetClosedLoopEnabled(bool closedLoopEnabled) { + HALSIM_SetPCMClosedLoopEnabled(m_index, closedLoopEnabled); + } + + std::unique_ptr RegisterPressureSwitchCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelPCMPressureSwitchCallback); + store->SetUid(HALSIM_RegisterPCMPressureSwitchCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + bool GetPressureSwitch() { return HALSIM_GetPCMPressureSwitch(m_index); } + void SetPressureSwitch(bool pressureSwitch) { + HALSIM_SetPCMPressureSwitch(m_index, pressureSwitch); + } + + std::unique_ptr RegisterCompressorCurrentCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelPCMCompressorCurrentCallback); + store->SetUid(HALSIM_RegisterPCMCompressorCurrentCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + double GetCompressorCurrent() { + return HALSIM_GetPCMCompressorCurrent(m_index); + } + void SetCompressorCurrent(double compressorCurrent) { + HALSIM_SetPCMCompressorCurrent(m_index, compressorCurrent); + } + + void ResetData() { HALSIM_ResetPCMData(m_index); } + + private: + int m_index; +}; +} // namespace sim +} // namespace frc +#endif // __FRC_ROBORIO__ diff --git a/hal/src/main/native/include/Simulation/PDPSim.h b/hal/src/main/native/include/Simulation/PDPSim.h new file mode 100644 index 0000000000..2ccfe4cb13 --- /dev/null +++ b/hal/src/main/native/include/Simulation/PDPSim.h @@ -0,0 +1,83 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#pragma once + +#ifndef __FRC_ROBORIO__ + +#include +#include + +#include "CallbackStore.h" +#include "MockData/PDPData.h" + +namespace frc { +namespace sim { +class PDPSim { + public: + explicit PDPSim(int index) { m_index = index; } + + std::unique_ptr RegisterInitializedCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelPDPInitializedCallback); + store->SetUid(HALSIM_RegisterPDPInitializedCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + bool GetInitialized() { return HALSIM_GetPDPInitialized(m_index); } + void SetInitialized(bool initialized) { + HALSIM_SetPDPInitialized(m_index, initialized); + } + + std::unique_ptr RegisterTemperatureCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelPDPTemperatureCallback); + store->SetUid(HALSIM_RegisterPDPTemperatureCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + double GetTemperature() { return HALSIM_GetPDPTemperature(m_index); } + void SetTemperature(double temperature) { + HALSIM_SetPDPTemperature(m_index, temperature); + } + + std::unique_ptr RegisterVoltageCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelPDPVoltageCallback); + store->SetUid(HALSIM_RegisterPDPVoltageCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + double GetVoltage() { return HALSIM_GetPDPVoltage(m_index); } + void SetVoltage(double voltage) { HALSIM_SetPDPVoltage(m_index, voltage); } + + std::unique_ptr RegisterCurrentCallback( + int channel, NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, channel, -1, callback, &HALSIM_CancelPDPCurrentCallback); + store->SetUid(HALSIM_RegisterPDPCurrentCallback( + m_index, channel, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + double GetCurrent(int channel) { + return HALSIM_GetPDPCurrent(m_index, channel); + } + void SetCurrent(int channel, double current) { + HALSIM_SetPDPCurrent(m_index, channel, current); + } + + void ResetData() { HALSIM_ResetPDPData(m_index); } + + private: + int m_index; +}; +} // namespace sim +} // namespace frc +#endif // __FRC_ROBORIO__ diff --git a/hal/src/main/native/include/Simulation/PWMSim.h b/hal/src/main/native/include/Simulation/PWMSim.h new file mode 100644 index 0000000000..c491e88920 --- /dev/null +++ b/hal/src/main/native/include/Simulation/PWMSim.h @@ -0,0 +1,105 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#pragma once + +#ifndef __FRC_ROBORIO__ + +#include +#include + +#include "CallbackStore.h" +#include "MockData/PWMData.h" + +namespace frc { +namespace sim { +class PWMSim { + public: + explicit PWMSim(int index) { m_index = index; } + + std::unique_ptr RegisterInitializedCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelPWMInitializedCallback); + store->SetUid(HALSIM_RegisterPWMInitializedCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + bool GetInitialized() { return HALSIM_GetPWMInitialized(m_index); } + void SetInitialized(bool initialized) { + HALSIM_SetPWMInitialized(m_index, initialized); + } + + std::unique_ptr RegisterRawValueCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelPWMRawValueCallback); + store->SetUid(HALSIM_RegisterPWMRawValueCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + int GetRawValue() { return HALSIM_GetPWMRawValue(m_index); } + void SetRawValue(int rawValue) { HALSIM_SetPWMRawValue(m_index, rawValue); } + + std::unique_ptr RegisterSpeedCallback(NotifyCallback callback, + bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelPWMSpeedCallback); + store->SetUid(HALSIM_RegisterPWMSpeedCallback(m_index, &CallbackStoreThunk, + store.get(), initialNotify)); + return std::move(store); + } + double GetSpeed() { return HALSIM_GetPWMSpeed(m_index); } + void SetSpeed(double speed) { HALSIM_SetPWMSpeed(m_index, speed); } + + std::unique_ptr RegisterPositionCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelPWMPositionCallback); + store->SetUid(HALSIM_RegisterPWMPositionCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + double GetPosition() { return HALSIM_GetPWMPosition(m_index); } + void SetPosition(double position) { + HALSIM_SetPWMPosition(m_index, position); + } + + std::unique_ptr RegisterPeriodScaleCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelPWMPeriodScaleCallback); + store->SetUid(HALSIM_RegisterPWMPeriodScaleCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + int GetPeriodScale() { return HALSIM_GetPWMPeriodScale(m_index); } + void SetPeriodScale(int periodScale) { + HALSIM_SetPWMPeriodScale(m_index, periodScale); + } + + std::unique_ptr RegisterZeroLatchCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelPWMZeroLatchCallback); + store->SetUid(HALSIM_RegisterPWMZeroLatchCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + bool GetZeroLatch() { return HALSIM_GetPWMZeroLatch(m_index); } + void SetZeroLatch(bool zeroLatch) { + HALSIM_SetPWMZeroLatch(m_index, zeroLatch); + } + + void ResetData() { HALSIM_ResetPWMData(m_index); } + + private: + int m_index; +}; +} // namespace sim +} // namespace frc +#endif // __FRC_ROBORIO__ diff --git a/hal/src/main/native/include/Simulation/RelaySim.h b/hal/src/main/native/include/Simulation/RelaySim.h new file mode 100644 index 0000000000..cc30f9141d --- /dev/null +++ b/hal/src/main/native/include/Simulation/RelaySim.h @@ -0,0 +1,83 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#pragma once + +#ifndef __FRC_ROBORIO__ + +#include +#include + +#include "CallbackStore.h" +#include "MockData/RelayData.h" + +namespace frc { +namespace sim { +class RelaySim { + public: + explicit RelaySim(int index) { m_index = index; } + + std::unique_ptr RegisterInitializedForwardCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelRelayInitializedForwardCallback); + store->SetUid(HALSIM_RegisterRelayInitializedForwardCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + bool GetInitializedForward() { + return HALSIM_GetRelayInitializedForward(m_index); + } + void SetInitializedForward(bool initializedForward) { + HALSIM_SetRelayInitializedForward(m_index, initializedForward); + } + + std::unique_ptr RegisterInitializedReverseCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelRelayInitializedReverseCallback); + store->SetUid(HALSIM_RegisterRelayInitializedReverseCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + bool GetInitializedReverse() { + return HALSIM_GetRelayInitializedReverse(m_index); + } + void SetInitializedReverse(bool initializedReverse) { + HALSIM_SetRelayInitializedReverse(m_index, initializedReverse); + } + + std::unique_ptr RegisterForwardCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelRelayForwardCallback); + store->SetUid(HALSIM_RegisterRelayForwardCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + bool GetForward() { return HALSIM_GetRelayForward(m_index); } + void SetForward(bool forward) { HALSIM_SetRelayForward(m_index, forward); } + + std::unique_ptr RegisterReverseCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelRelayReverseCallback); + store->SetUid(HALSIM_RegisterRelayReverseCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + bool GetReverse() { return HALSIM_GetRelayReverse(m_index); } + void SetReverse(bool reverse) { HALSIM_SetRelayReverse(m_index, reverse); } + + void ResetData() { HALSIM_ResetRelayData(m_index); } + + private: + int m_index; +}; +} // namespace sim +} // namespace frc +#endif // __FRC_ROBORIO__ diff --git a/hal/src/main/native/include/Simulation/RoboRioSim.h b/hal/src/main/native/include/Simulation/RoboRioSim.h new file mode 100644 index 0000000000..d88f339635 --- /dev/null +++ b/hal/src/main/native/include/Simulation/RoboRioSim.h @@ -0,0 +1,230 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#pragma once + +#ifndef __FRC_ROBORIO__ + +#include +#include + +#include "CallbackStore.h" +#include "MockData/RoboRioData.h" + +namespace frc { +namespace sim { +class RoboRioSim { + public: + explicit RoboRioSim(int index) { m_index = index; } + + std::unique_ptr RegisterFPGAButtonCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelRoboRioFPGAButtonCallback); + store->SetUid(HALSIM_RegisterRoboRioFPGAButtonCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + bool GetFPGAButton() { return HALSIM_GetRoboRioFPGAButton(m_index); } + void SetFPGAButton(bool fPGAButton) { + HALSIM_SetRoboRioFPGAButton(m_index, fPGAButton); + } + + std::unique_ptr RegisterVInVoltageCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelRoboRioVInVoltageCallback); + store->SetUid(HALSIM_RegisterRoboRioVInVoltageCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + double GetVInVoltage() { return HALSIM_GetRoboRioVInVoltage(m_index); } + void SetVInVoltage(double vInVoltage) { + HALSIM_SetRoboRioVInVoltage(m_index, vInVoltage); + } + + std::unique_ptr RegisterVInCurrentCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelRoboRioVInCurrentCallback); + store->SetUid(HALSIM_RegisterRoboRioVInCurrentCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + double GetVInCurrent() { return HALSIM_GetRoboRioVInCurrent(m_index); } + void SetVInCurrent(double vInCurrent) { + HALSIM_SetRoboRioVInCurrent(m_index, vInCurrent); + } + + std::unique_ptr RegisterUserVoltage6VCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelRoboRioUserVoltage6VCallback); + store->SetUid(HALSIM_RegisterRoboRioUserVoltage6VCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + double GetUserVoltage6V() { return HALSIM_GetRoboRioUserVoltage6V(m_index); } + void SetUserVoltage6V(double userVoltage6V) { + HALSIM_SetRoboRioUserVoltage6V(m_index, userVoltage6V); + } + + std::unique_ptr RegisterUserCurrent6VCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelRoboRioUserCurrent6VCallback); + store->SetUid(HALSIM_RegisterRoboRioUserCurrent6VCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + double GetUserCurrent6V() { return HALSIM_GetRoboRioUserCurrent6V(m_index); } + void SetUserCurrent6V(double userCurrent6V) { + HALSIM_SetRoboRioUserCurrent6V(m_index, userCurrent6V); + } + + std::unique_ptr RegisterUserActive6VCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelRoboRioUserActive6VCallback); + store->SetUid(HALSIM_RegisterRoboRioUserActive6VCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + bool GetUserActive6V() { return HALSIM_GetRoboRioUserActive6V(m_index); } + void SetUserActive6V(bool userActive6V) { + HALSIM_SetRoboRioUserActive6V(m_index, userActive6V); + } + + std::unique_ptr RegisterUserVoltage5VCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelRoboRioUserVoltage5VCallback); + store->SetUid(HALSIM_RegisterRoboRioUserVoltage5VCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + double GetUserVoltage5V() { return HALSIM_GetRoboRioUserVoltage5V(m_index); } + void SetUserVoltage5V(double userVoltage5V) { + HALSIM_SetRoboRioUserVoltage5V(m_index, userVoltage5V); + } + + std::unique_ptr RegisterUserCurrent5VCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelRoboRioUserCurrent5VCallback); + store->SetUid(HALSIM_RegisterRoboRioUserCurrent5VCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + double GetUserCurrent5V() { return HALSIM_GetRoboRioUserCurrent5V(m_index); } + void SetUserCurrent5V(double userCurrent5V) { + HALSIM_SetRoboRioUserCurrent5V(m_index, userCurrent5V); + } + + std::unique_ptr RegisterUserActive5VCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelRoboRioUserActive5VCallback); + store->SetUid(HALSIM_RegisterRoboRioUserActive5VCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + bool GetUserActive5V() { return HALSIM_GetRoboRioUserActive5V(m_index); } + void SetUserActive5V(bool userActive5V) { + HALSIM_SetRoboRioUserActive5V(m_index, userActive5V); + } + + std::unique_ptr RegisterUserVoltage3V3Callback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelRoboRioUserVoltage3V3Callback); + store->SetUid(HALSIM_RegisterRoboRioUserVoltage3V3Callback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + double GetUserVoltage3V3() { + return HALSIM_GetRoboRioUserVoltage3V3(m_index); + } + void SetUserVoltage3V3(double userVoltage3V3) { + HALSIM_SetRoboRioUserVoltage3V3(m_index, userVoltage3V3); + } + + std::unique_ptr RegisterUserCurrent3V3Callback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelRoboRioUserCurrent3V3Callback); + store->SetUid(HALSIM_RegisterRoboRioUserCurrent3V3Callback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + double GetUserCurrent3V3() { + return HALSIM_GetRoboRioUserCurrent3V3(m_index); + } + void SetUserCurrent3V3(double userCurrent3V3) { + HALSIM_SetRoboRioUserCurrent3V3(m_index, userCurrent3V3); + } + + std::unique_ptr RegisterUserActive3V3Callback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelRoboRioUserActive3V3Callback); + store->SetUid(HALSIM_RegisterRoboRioUserActive3V3Callback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + bool GetUserActive3V3() { return HALSIM_GetRoboRioUserActive3V3(m_index); } + void SetUserActive3V3(bool userActive3V3) { + HALSIM_SetRoboRioUserActive3V3(m_index, userActive3V3); + } + + std::unique_ptr RegisterUserFaults6VCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelRoboRioUserFaults6VCallback); + store->SetUid(HALSIM_RegisterRoboRioUserFaults6VCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + int GetUserFaults6V() { return HALSIM_GetRoboRioUserFaults6V(m_index); } + void SetUserFaults6V(int userFaults6V) { + HALSIM_SetRoboRioUserFaults6V(m_index, userFaults6V); + } + + std::unique_ptr RegisterUserFaults5VCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelRoboRioUserFaults5VCallback); + store->SetUid(HALSIM_RegisterRoboRioUserFaults5VCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + int GetUserFaults5V() { return HALSIM_GetRoboRioUserFaults5V(m_index); } + void SetUserFaults5V(int userFaults5V) { + HALSIM_SetRoboRioUserFaults5V(m_index, userFaults5V); + } + + std::unique_ptr RegisterUserFaults3V3Callback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelRoboRioUserFaults3V3Callback); + store->SetUid(HALSIM_RegisterRoboRioUserFaults3V3Callback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + int GetUserFaults3V3() { return HALSIM_GetRoboRioUserFaults3V3(m_index); } + void SetUserFaults3V3(int userFaults3V3) { + HALSIM_SetRoboRioUserFaults3V3(m_index, userFaults3V3); + } + + void ResetData() { HALSIM_ResetRoboRioData(m_index); } + + private: + int m_index; +}; +} // namespace sim +} // namespace frc +#endif // __FRC_ROBORIO__ diff --git a/hal/src/main/native/include/Simulation/SPIAccelerometerSim.h b/hal/src/main/native/include/Simulation/SPIAccelerometerSim.h new file mode 100644 index 0000000000..47fd77643b --- /dev/null +++ b/hal/src/main/native/include/Simulation/SPIAccelerometerSim.h @@ -0,0 +1,88 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#pragma once + +#ifndef __FRC_ROBORIO__ + +#include +#include + +#include "CallbackStore.h" +#include "MockData/SPIAccelerometerData.h" + +namespace frc { +namespace sim { +class SPIAccelerometerSim { + public: + explicit SPIAccelerometerSim(int index) { m_index = index; } + + std::unique_ptr RegisterActiveCallback(NotifyCallback callback, + bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelSPIAccelerometerActiveCallback); + store->SetUid(HALSIM_RegisterSPIAccelerometerActiveCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + bool GetActive() { return HALSIM_GetSPIAccelerometerActive(m_index); } + void SetActive(bool active) { + HALSIM_SetSPIAccelerometerActive(m_index, active); + } + + std::unique_ptr RegisterRangeCallback(NotifyCallback callback, + bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelSPIAccelerometerRangeCallback); + store->SetUid(HALSIM_RegisterSPIAccelerometerRangeCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + int GetRange() { return HALSIM_GetSPIAccelerometerRange(m_index); } + void SetRange(int range) { HALSIM_SetSPIAccelerometerRange(m_index, range); } + + std::unique_ptr RegisterXCallback(NotifyCallback callback, + bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelSPIAccelerometerXCallback); + store->SetUid(HALSIM_RegisterSPIAccelerometerXCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + double GetX() { return HALSIM_GetSPIAccelerometerX(m_index); } + void SetX(double x) { HALSIM_SetSPIAccelerometerX(m_index, x); } + + std::unique_ptr RegisterYCallback(NotifyCallback callback, + bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelSPIAccelerometerYCallback); + store->SetUid(HALSIM_RegisterSPIAccelerometerYCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + double GetY() { return HALSIM_GetSPIAccelerometerY(m_index); } + void SetY(double y) { HALSIM_SetSPIAccelerometerY(m_index, y); } + + std::unique_ptr RegisterZCallback(NotifyCallback callback, + bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelSPIAccelerometerZCallback); + store->SetUid(HALSIM_RegisterSPIAccelerometerZCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return std::move(store); + } + double GetZ() { return HALSIM_GetSPIAccelerometerZ(m_index); } + void SetZ(double z) { HALSIM_SetSPIAccelerometerZ(m_index, z); } + + void ResetData() { HALSIM_ResetSPIAccelerometerData(m_index); } + + private: + int m_index; +}; +} // namespace sim +} // namespace frc +#endif // __FRC_ROBORIO__ diff --git a/hal/src/main/native/include/Simulation/SimHooks.h b/hal/src/main/native/include/Simulation/SimHooks.h new file mode 100644 index 0000000000..9ca7434b73 --- /dev/null +++ b/hal/src/main/native/include/Simulation/SimHooks.h @@ -0,0 +1,22 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#pragma once + +#ifndef __FRC_ROBORIO__ + +#include "MockData/MockHooks.h" + +namespace frc { +namespace sim { +void WaitForProgramStart() { HALSIM_WaitForProgramStart(); } +void SetProgramStarted() { HALSIM_SetProgramStarted(); } +void RestartTiming() { HALSIM_RestartTiming(); } +} // namespace sim +} // namespace frc + +#endif diff --git a/hal/src/main/native/sim/CallbackStore.cpp b/hal/src/main/native/sim/CallbackStore.cpp new file mode 100644 index 0000000000..e1741a1878 --- /dev/null +++ b/hal/src/main/native/sim/CallbackStore.cpp @@ -0,0 +1,13 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#include "Simulation/CallbackStore.h" + +void frc::sim::CallbackStoreThunk(const char* name, void* param, + const HAL_Value* value) { + reinterpret_cast(param)->callback(name, value); +} diff --git a/hal/src/main/native/sim/jni/AccelerometerDataJNI.cpp b/hal/src/main/native/sim/jni/AccelerometerDataJNI.cpp new file mode 100644 index 0000000000..ad9ef5039a --- /dev/null +++ b/hal/src/main/native/sim/jni/AccelerometerDataJNI.cpp @@ -0,0 +1,161 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#include + +#include "CallbackStore.h" +#include "MockData/AccelerometerData.h" +#include "edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI.h" + +extern "C" { + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_registerActiveCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterAccelerometerActiveCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_cancelActiveCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelAccelerometerActiveCallback); +} + +JNIEXPORT jboolean JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_getActive(JNIEnv*, + jclass, + jint index) { + return HALSIM_GetAccelerometerActive(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_setActive( + JNIEnv*, jclass, jint index, jboolean value) { + HALSIM_SetAccelerometerActive(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_registerRangeCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterAccelerometerRangeCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_cancelRangeCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelAccelerometerRangeCallback); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_getRange(JNIEnv*, + jclass, + jint index) { + return HALSIM_GetAccelerometerRange(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_setRange(JNIEnv*, + jclass, + jint index, + jint value) { + HALSIM_SetAccelerometerRange(index, + static_cast(value)); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_registerXCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterAccelerometerXCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_cancelXCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelAccelerometerXCallback); +} + +JNIEXPORT jdouble JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_getX(JNIEnv*, jclass, + jint index) { + return HALSIM_GetAccelerometerX(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_setX(JNIEnv*, jclass, + jint index, + jdouble value) { + HALSIM_SetAccelerometerX(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_registerYCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterAccelerometerYCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_cancelYCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelAccelerometerYCallback); +} + +JNIEXPORT jdouble JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_getY(JNIEnv*, jclass, + jint index) { + return HALSIM_GetAccelerometerY(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_setY(JNIEnv*, jclass, + jint index, + jdouble value) { + HALSIM_SetAccelerometerY(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_registerZCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterAccelerometerZCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_cancelZCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelAccelerometerZCallback); +} + +JNIEXPORT jdouble JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_getZ(JNIEnv*, jclass, + jint index) { + return HALSIM_GetAccelerometerZ(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_setZ(JNIEnv*, jclass, + jint index, + jdouble value) { + HALSIM_SetAccelerometerZ(index, value); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_resetData(JNIEnv*, + jclass, + jint index) { + HALSIM_ResetAccelerometerData(index); +} + +} // extern "C" diff --git a/hal/src/main/native/sim/jni/AnalogGyroDataJNI.cpp b/hal/src/main/native/sim/jni/AnalogGyroDataJNI.cpp new file mode 100644 index 0000000000..c21b4733ce --- /dev/null +++ b/hal/src/main/native/sim/jni/AnalogGyroDataJNI.cpp @@ -0,0 +1,102 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#include + +#include "CallbackStore.h" +#include "MockData/AnalogGyroData.h" +#include "edu_wpi_first_hal_sim_mockdata_AnalogGyroDataJNI.h" + +extern "C" { + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogGyroDataJNI_registerAngleCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterAnalogGyroAngleCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogGyroDataJNI_cancelAngleCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelAnalogGyroAngleCallback); +} + +JNIEXPORT jdouble JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogGyroDataJNI_getAngle(JNIEnv*, jclass, + jint index) { + return HALSIM_GetAnalogGyroAngle(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogGyroDataJNI_setAngle(JNIEnv*, jclass, + jint index, + jdouble value) { + HALSIM_SetAnalogGyroAngle(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogGyroDataJNI_registerRateCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterAnalogGyroRateCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogGyroDataJNI_cancelRateCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelAnalogGyroRateCallback); +} + +JNIEXPORT jdouble JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogGyroDataJNI_getRate(JNIEnv*, jclass, + jint index) { + return HALSIM_GetAnalogGyroRate(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogGyroDataJNI_setRate(JNIEnv*, jclass, + jint index, + jdouble value) { + HALSIM_SetAnalogGyroRate(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogGyroDataJNI_registerInitializedCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterAnalogGyroInitializedCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogGyroDataJNI_cancelInitializedCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelAnalogGyroInitializedCallback); +} + +JNIEXPORT jboolean JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogGyroDataJNI_getInitialized( + JNIEnv*, jclass, jint index) { + return HALSIM_GetAnalogGyroInitialized(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogGyroDataJNI_setInitialized( + JNIEnv*, jclass, jint index, jboolean value) { + HALSIM_SetAnalogGyroInitialized(index, value); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogGyroDataJNI_resetData(JNIEnv*, jclass, + jint index) { + HALSIM_ResetAnalogGyroData(index); +} + +} // extern "C" diff --git a/hal/src/main/native/sim/jni/AnalogInDataJNI.cpp b/hal/src/main/native/sim/jni/AnalogInDataJNI.cpp new file mode 100644 index 0000000000..a7df17ddec --- /dev/null +++ b/hal/src/main/native/sim/jni/AnalogInDataJNI.cpp @@ -0,0 +1,266 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#include + +#include "CallbackStore.h" +#include "MockData/AnalogInData.h" +#include "edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI.h" + +extern "C" { + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_registerInitializedCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterAnalogInInitializedCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_cancelInitializedCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelAnalogInInitializedCallback); +} + +JNIEXPORT jboolean JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_getInitialized(JNIEnv*, + jclass, + jint index) { + return HALSIM_GetAnalogInInitialized(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_setInitialized( + JNIEnv*, jclass, jint index, jboolean value) { + HALSIM_SetAnalogInInitialized(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_registerAverageBitsCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterAnalogInAverageBitsCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_cancelAverageBitsCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelAnalogInAverageBitsCallback); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_getAverageBits(JNIEnv*, + jclass, + jint index) { + return HALSIM_GetAnalogInAverageBits(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_setAverageBits(JNIEnv*, + jclass, + jint index, + jint value) { + HALSIM_SetAnalogInAverageBits(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_registerOversampleBitsCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterAnalogInOversampleBitsCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_cancelOversampleBitsCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelAnalogInOversampleBitsCallback); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_getOversampleBits( + JNIEnv*, jclass, jint index) { + return HALSIM_GetAnalogInOversampleBits(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_setOversampleBits( + JNIEnv*, jclass, jint index, jint value) { + HALSIM_SetAnalogInOversampleBits(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_registerVoltageCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterAnalogInVoltageCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_cancelVoltageCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelAnalogInVoltageCallback); +} + +JNIEXPORT jdouble JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_getVoltage(JNIEnv*, jclass, + jint index) { + return HALSIM_GetAnalogInVoltage(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_setVoltage(JNIEnv*, jclass, + jint index, + jdouble value) { + HALSIM_SetAnalogInVoltage(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_registerAccumulatorInitializedCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback( + env, index, callback, initialNotify, + &HALSIM_RegisterAnalogInAccumulatorInitializedCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_cancelAccumulatorInitializedCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback( + env, handle, index, &HALSIM_CancelAnalogInAccumulatorInitializedCallback); +} + +JNIEXPORT jboolean JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_getAccumulatorInitialized( + JNIEnv*, jclass, jint index) { + return HALSIM_GetAnalogInAccumulatorInitialized(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_setAccumulatorInitialized( + JNIEnv*, jclass, jint index, jboolean value) { + HALSIM_SetAnalogInAccumulatorInitialized(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_registerAccumulatorValueCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback( + env, index, callback, initialNotify, + &HALSIM_RegisterAnalogInAccumulatorValueCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_cancelAccumulatorValueCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelAnalogInAccumulatorValueCallback); +} + +JNIEXPORT jlong JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_getAccumulatorValue( + JNIEnv*, jclass, jint index) { + return HALSIM_GetAnalogInAccumulatorValue(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_setAccumulatorValue( + JNIEnv*, jclass, jint index, jlong value) { + HALSIM_SetAnalogInAccumulatorValue(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_registerAccumulatorCountCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback( + env, index, callback, initialNotify, + &HALSIM_RegisterAnalogInAccumulatorCountCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_cancelAccumulatorCountCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelAnalogInAccumulatorCountCallback); +} + +JNIEXPORT jlong JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_getAccumulatorCount( + JNIEnv*, jclass, jint index) { + return HALSIM_GetAnalogInAccumulatorCount(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_setAccumulatorCount( + JNIEnv*, jclass, jint index, jlong value) { + HALSIM_SetAnalogInAccumulatorCount(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_registerAccumulatorCenterCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback( + env, index, callback, initialNotify, + &HALSIM_RegisterAnalogInAccumulatorCenterCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_cancelAccumulatorCenterCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelAnalogInAccumulatorCenterCallback); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_getAccumulatorCenter( + JNIEnv*, jclass, jint index) { + return HALSIM_GetAnalogInAccumulatorCenter(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_setAccumulatorCenter( + JNIEnv*, jclass, jint index, jint value) { + HALSIM_SetAnalogInAccumulatorCenter(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_registerAccumulatorDeadbandCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback( + env, index, callback, initialNotify, + &HALSIM_RegisterAnalogInAccumulatorDeadbandCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_cancelAccumulatorDeadbandCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelAnalogInAccumulatorDeadbandCallback); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_getAccumulatorDeadband( + JNIEnv*, jclass, jint index) { + return HALSIM_GetAnalogInAccumulatorDeadband(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_setAccumulatorDeadband( + JNIEnv*, jclass, jint index, jint value) { + HALSIM_SetAnalogInAccumulatorDeadband(index, value); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_resetData(JNIEnv*, jclass, + jint index) { + HALSIM_ResetAnalogInData(index); +} + +} // extern "C" diff --git a/hal/src/main/native/sim/jni/AnalogOutDataJNI.cpp b/hal/src/main/native/sim/jni/AnalogOutDataJNI.cpp new file mode 100644 index 0000000000..d63bf6da01 --- /dev/null +++ b/hal/src/main/native/sim/jni/AnalogOutDataJNI.cpp @@ -0,0 +1,75 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#include + +#include "CallbackStore.h" +#include "MockData/AnalogOutData.h" +#include "edu_wpi_first_hal_sim_mockdata_AnalogOutDataJNI.h" + +extern "C" { + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogOutDataJNI_registerVoltageCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterAnalogOutVoltageCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogOutDataJNI_cancelVoltageCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelAnalogOutVoltageCallback); +} + +JNIEXPORT jdouble JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogOutDataJNI_getVoltage(JNIEnv*, jclass, + jint index) { + return HALSIM_GetAnalogOutVoltage(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogOutDataJNI_setVoltage(JNIEnv*, jclass, + jint index, + jdouble value) { + HALSIM_SetAnalogOutVoltage(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogOutDataJNI_registerInitializedCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterAnalogOutInitializedCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogOutDataJNI_cancelInitializedCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelAnalogOutInitializedCallback); +} + +JNIEXPORT jboolean JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogOutDataJNI_getInitialized( + JNIEnv*, jclass, jint index) { + return HALSIM_GetAnalogOutInitialized(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogOutDataJNI_setInitialized( + JNIEnv*, jclass, jint index, jboolean value) { + HALSIM_SetAnalogOutInitialized(index, value); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogOutDataJNI_resetData(JNIEnv*, jclass, + jint index) { + HALSIM_ResetAnalogOutData(index); +} + +} // extern "C" diff --git a/hal/src/main/native/sim/jni/AnalogTriggerDataJNI.cpp b/hal/src/main/native/sim/jni/AnalogTriggerDataJNI.cpp new file mode 100644 index 0000000000..842beb3957 --- /dev/null +++ b/hal/src/main/native/sim/jni/AnalogTriggerDataJNI.cpp @@ -0,0 +1,104 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#include + +#include "CallbackStore.h" +#include "MockData/AnalogTriggerData.h" +#include "edu_wpi_first_hal_sim_mockdata_AnalogTriggerDataJNI.h" + +extern "C" { + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogTriggerDataJNI_registerInitializedCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback( + env, index, callback, initialNotify, + &HALSIM_RegisterAnalogTriggerInitializedCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogTriggerDataJNI_cancelInitializedCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelAnalogTriggerInitializedCallback); +} + +JNIEXPORT jboolean JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogTriggerDataJNI_getInitialized( + JNIEnv*, jclass, jint index) { + return HALSIM_GetAnalogTriggerInitialized(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogTriggerDataJNI_setInitialized( + JNIEnv*, jclass, jint index, jboolean value) { + HALSIM_SetAnalogTriggerInitialized(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogTriggerDataJNI_registerTriggerLowerBoundCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback( + env, index, callback, initialNotify, + &HALSIM_RegisterAnalogTriggerTriggerLowerBoundCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogTriggerDataJNI_cancelTriggerLowerBoundCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback( + env, handle, index, &HALSIM_CancelAnalogTriggerTriggerLowerBoundCallback); +} + +JNIEXPORT jdouble JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogTriggerDataJNI_getTriggerLowerBound( + JNIEnv*, jclass, jint index) { + return HALSIM_GetAnalogTriggerTriggerLowerBound(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogTriggerDataJNI_setTriggerLowerBound( + JNIEnv*, jclass, jint index, jdouble value) { + HALSIM_SetAnalogTriggerTriggerLowerBound(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogTriggerDataJNI_registerTriggerUpperBoundCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback( + env, index, callback, initialNotify, + &HALSIM_RegisterAnalogTriggerTriggerUpperBoundCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogTriggerDataJNI_cancelTriggerUpperBoundCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback( + env, handle, index, &HALSIM_CancelAnalogTriggerTriggerUpperBoundCallback); +} + +JNIEXPORT jdouble JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogTriggerDataJNI_getTriggerUpperBound( + JNIEnv*, jclass, jint index) { + return HALSIM_GetAnalogTriggerTriggerUpperBound(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogTriggerDataJNI_setTriggerUpperBound( + JNIEnv*, jclass, jint index, jdouble value) { + HALSIM_SetAnalogTriggerTriggerUpperBound(index, value); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_AnalogTriggerDataJNI_resetData(JNIEnv*, + jclass, + jint index) { + HALSIM_ResetAnalogTriggerData(index); +} + +} // extern "C" diff --git a/hal/src/main/native/sim/jni/BufferCallbackStore.cpp b/hal/src/main/native/sim/jni/BufferCallbackStore.cpp new file mode 100644 index 0000000000..917dac56a4 --- /dev/null +++ b/hal/src/main/native/sim/jni/BufferCallbackStore.cpp @@ -0,0 +1,124 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#include "BufferCallbackStore.h" + +#include +#include + +#include "HAL/Types.h" +#include "HAL/handles/UnlimitedHandleResource.h" +#include "MockData/HAL_Value.h" +#include "MockData/NotifyListener.h" +#include "SimulatorJNI.h" + +using namespace wpi::java; +using namespace sim; + +static hal::UnlimitedHandleResource* + callbackHandles; + +namespace sim { +void InitializeBufferStore() { + static hal::UnlimitedHandleResource + cb; + callbackHandles = &cb; +} +} // namespace sim + +void BufferCallbackStore::create(JNIEnv* env, jobject obj) { + m_call = JGlobal(env, obj); +} + +void BufferCallbackStore::performCallback(const char* name, uint8_t* buffer, + uint32_t length) { + JNIEnv* env; + JavaVM* vm = sim::GetJVM(); + bool didAttachThread = false; + int tryGetEnv = vm->GetEnv(reinterpret_cast(&env), JNI_VERSION_1_6); + if (tryGetEnv == JNI_EDETACHED) { + // Thread not attached + didAttachThread = true; + if (vm->AttachCurrentThread(reinterpret_cast(&env), nullptr) != 0) { + // Failed to attach, log and return + wpi::outs() << "Failed to attach\n"; + wpi::outs().flush(); + return; + } + } else if (tryGetEnv == JNI_EVERSION) { + wpi::outs() << "Invalid JVM Version requested\n"; + wpi::outs().flush(); + } + + auto toCallbackArr = + MakeJByteArray(env, wpi::StringRef{reinterpret_cast(buffer), + static_cast(length)}); + + env->CallVoidMethod(m_call, sim::GetBufferCallback(), MakeJString(env, name), + toCallbackArr, (jint)length); + + jbyte* fromCallbackArr = reinterpret_cast( + env->GetPrimitiveArrayCritical(toCallbackArr, nullptr)); + + for (size_t i = 0; i < length; i++) { + buffer[i] = fromCallbackArr[i]; + } + + env->ReleasePrimitiveArrayCritical(toCallbackArr, fromCallbackArr, JNI_ABORT); + + if (env->ExceptionCheck()) { + env->ExceptionDescribe(); + } + + if (didAttachThread) { + vm->DetachCurrentThread(); + } +} + +void BufferCallbackStore::free(JNIEnv* env) { m_call.free(env); } + +SIM_JniHandle sim::AllocateBufferCallback( + JNIEnv* env, jint index, jobject callback, + RegisterBufferCallbackFunc createCallback) { + auto callbackStore = std::make_shared(); + + auto handle = callbackHandles->Allocate(callbackStore); + + if (handle == HAL_kInvalidHandle) { + return -1; + } + + uintptr_t handleAsPtr = static_cast(handle); + void* handleAsVoidPtr = reinterpret_cast(handleAsPtr); + + callbackStore->create(env, callback); + + auto callbackFunc = [](const char* name, void* param, uint8_t* buffer, + uint32_t length) { + uintptr_t handleTmp = reinterpret_cast(param); + SIM_JniHandle handle = static_cast(handleTmp); + auto data = callbackHandles->Get(handle); + if (!data) return; + + data->performCallback(name, buffer, length); + }; + + auto id = createCallback(index, callbackFunc, handleAsVoidPtr); + + callbackStore->setCallbackId(id); + + return handle; +} + +void sim::FreeBufferCallback(JNIEnv* env, SIM_JniHandle handle, jint index, + FreeBufferCallbackFunc freeCallback) { + auto callback = callbackHandles->Free(handle); + freeCallback(index, callback->getCallbackId()); + callback->free(env); +} diff --git a/hal/src/main/native/sim/jni/BufferCallbackStore.h b/hal/src/main/native/sim/jni/BufferCallbackStore.h new file mode 100644 index 0000000000..41b451de0b --- /dev/null +++ b/hal/src/main/native/sim/jni/BufferCallbackStore.h @@ -0,0 +1,44 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#pragma once + +#include +#include + +#include "HAL/Types.h" +#include "HAL/handles/UnlimitedHandleResource.h" +#include "MockData/HAL_Value.h" +#include "MockData/NotifyListener.h" +#include "SimulatorJNI.h" + +namespace sim { +class BufferCallbackStore { + public: + void create(JNIEnv* env, jobject obj); + void performCallback(const char* name, uint8_t* buffer, uint32_t length); + void free(JNIEnv* env); + void setCallbackId(int32_t id) { callbackId = id; } + int32_t getCallbackId() { return callbackId; } + + private: + wpi::java::JGlobal m_call; + int32_t callbackId; +}; + +void InitializeBufferStore(); + +typedef int32_t (*RegisterBufferCallbackFunc)(int32_t index, + HAL_BufferCallback callback, + void* param); +typedef void (*FreeBufferCallbackFunc)(int32_t index, int32_t uid); + +SIM_JniHandle AllocateBufferCallback(JNIEnv* env, jint index, jobject callback, + RegisterBufferCallbackFunc createCallback); +void FreeBufferCallback(JNIEnv* env, SIM_JniHandle handle, jint index, + FreeBufferCallbackFunc freeCallback); +} // namespace sim diff --git a/hal/src/main/native/sim/jni/CallbackStore.cpp b/hal/src/main/native/sim/jni/CallbackStore.cpp new file mode 100644 index 0000000000..1e51c0b0d9 --- /dev/null +++ b/hal/src/main/native/sim/jni/CallbackStore.cpp @@ -0,0 +1,193 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#include "CallbackStore.h" + +#include +#include + +#include "HAL/Types.h" +#include "HAL/handles/UnlimitedHandleResource.h" +#include "MockData/HAL_Value.h" +#include "MockData/NotifyListener.h" +#include "SimulatorJNI.h" + +using namespace wpi::java; +using namespace sim; + +static hal::UnlimitedHandleResource* + callbackHandles; + +namespace sim { +void InitializeStore() { + static hal::UnlimitedHandleResource + cb; + callbackHandles = &cb; +} +} // namespace sim + +void CallbackStore::create(JNIEnv* env, jobject obj) { + m_call = JGlobal(env, obj); +} + +void CallbackStore::performCallback(const char* name, const HAL_Value* value) { + JNIEnv* env; + JavaVM* vm = sim::GetJVM(); + bool didAttachThread = false; + int tryGetEnv = vm->GetEnv(reinterpret_cast(&env), JNI_VERSION_1_6); + if (tryGetEnv == JNI_EDETACHED) { + // Thread not attached + didAttachThread = true; + if (vm->AttachCurrentThread(reinterpret_cast(&env), nullptr) != 0) { + // Failed to attach, log and return + wpi::outs() << "Failed to attach\n"; + wpi::outs().flush(); + return; + } + } else if (tryGetEnv == JNI_EVERSION) { + wpi::outs() << "Invalid JVM Version requested\n"; + wpi::outs().flush(); + } + + env->CallVoidMethod(m_call, sim::GetNotifyCallback(), MakeJString(env, name), + (jint)value->type, (jlong)value->data.v_long, + (jdouble)value->data.v_double); + + if (env->ExceptionCheck()) { + env->ExceptionDescribe(); + } + + if (didAttachThread) { + vm->DetachCurrentThread(); + } +} + +void CallbackStore::free(JNIEnv* env) { m_call.free(env); } + +SIM_JniHandle sim::AllocateCallback(JNIEnv* env, jint index, jobject callback, + jboolean initialNotify, + RegisterCallbackFunc createCallback) { + auto callbackStore = std::make_shared(); + + auto handle = callbackHandles->Allocate(callbackStore); + + if (handle == HAL_kInvalidHandle) { + return -1; + } + + uintptr_t handleAsPtr = static_cast(handle); + void* handleAsVoidPtr = reinterpret_cast(handleAsPtr); + + callbackStore->create(env, callback); + + auto callbackFunc = [](const char* name, void* param, + const HAL_Value* value) { + uintptr_t handleTmp = reinterpret_cast(param); + SIM_JniHandle handle = static_cast(handleTmp); + auto data = callbackHandles->Get(handle); + if (!data) return; + + data->performCallback(name, value); + }; + + auto id = createCallback(index, callbackFunc, handleAsVoidPtr, initialNotify); + + callbackStore->setCallbackId(id); + + return handle; +} + +void sim::FreeCallback(JNIEnv* env, SIM_JniHandle handle, jint index, + FreeCallbackFunc freeCallback) { + auto callback = callbackHandles->Free(handle); + freeCallback(index, callback->getCallbackId()); + callback->free(env); +} + +SIM_JniHandle sim::AllocateChannelCallback( + JNIEnv* env, jint index, jint channel, jobject callback, + jboolean initialNotify, RegisterChannelCallbackFunc createCallback) { + auto callbackStore = std::make_shared(); + + auto handle = callbackHandles->Allocate(callbackStore); + + if (handle == HAL_kInvalidHandle) { + return -1; + } + + uintptr_t handleAsPtr = static_cast(handle); + void* handleAsVoidPtr = reinterpret_cast(handleAsPtr); + + callbackStore->create(env, callback); + + auto callbackFunc = [](const char* name, void* param, + const HAL_Value* value) { + uintptr_t handleTmp = reinterpret_cast(param); + SIM_JniHandle handle = static_cast(handleTmp); + auto data = callbackHandles->Get(handle); + if (!data) return; + + data->performCallback(name, value); + }; + + auto id = createCallback(index, channel, callbackFunc, handleAsVoidPtr, + initialNotify); + + callbackStore->setCallbackId(id); + + return handle; +} + +void sim::FreeChannelCallback(JNIEnv* env, SIM_JniHandle handle, jint index, + jint channel, + FreeChannelCallbackFunc freeCallback) { + auto callback = callbackHandles->Free(handle); + freeCallback(index, channel, callback->getCallbackId()); + callback->free(env); +} + +SIM_JniHandle sim::AllocateCallbackNoIndex( + JNIEnv* env, jobject callback, jboolean initialNotify, + RegisterCallbackNoIndexFunc createCallback) { + auto callbackStore = std::make_shared(); + + auto handle = callbackHandles->Allocate(callbackStore); + + if (handle == HAL_kInvalidHandle) { + return -1; + } + + uintptr_t handleAsPtr = static_cast(handle); + void* handleAsVoidPtr = reinterpret_cast(handleAsPtr); + + callbackStore->create(env, callback); + + auto callbackFunc = [](const char* name, void* param, + const HAL_Value* value) { + uintptr_t handleTmp = reinterpret_cast(param); + SIM_JniHandle handle = static_cast(handleTmp); + auto data = callbackHandles->Get(handle); + if (!data) return; + + data->performCallback(name, value); + }; + + auto id = createCallback(callbackFunc, handleAsVoidPtr, initialNotify); + + callbackStore->setCallbackId(id); + + return handle; +} + +void sim::FreeCallbackNoIndex(JNIEnv* env, SIM_JniHandle handle, + FreeCallbackNoIndexFunc freeCallback) { + auto callback = callbackHandles->Free(handle); + freeCallback(callback->getCallbackId()); + callback->free(env); +} diff --git a/hal/src/main/native/sim/jni/CallbackStore.h b/hal/src/main/native/sim/jni/CallbackStore.h new file mode 100644 index 0000000000..80cfc88caf --- /dev/null +++ b/hal/src/main/native/sim/jni/CallbackStore.h @@ -0,0 +1,65 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#pragma once + +#include +#include + +#include "HAL/Types.h" +#include "HAL/handles/UnlimitedHandleResource.h" +#include "MockData/HAL_Value.h" +#include "MockData/NotifyListener.h" +#include "SimulatorJNI.h" + +namespace sim { +class CallbackStore { + public: + void create(JNIEnv* env, jobject obj); + void performCallback(const char* name, const HAL_Value* value); + void free(JNIEnv* env); + void setCallbackId(int32_t id) { callbackId = id; } + int32_t getCallbackId() { return callbackId; } + + private: + wpi::java::JGlobal m_call; + int32_t callbackId; +}; + +void InitializeStore(); + +typedef int32_t (*RegisterCallbackFunc)(int32_t index, + HAL_NotifyCallback callback, + void* param, HAL_Bool initialNotify); +typedef void (*FreeCallbackFunc)(int32_t index, int32_t uid); +typedef int32_t (*RegisterChannelCallbackFunc)(int32_t index, int32_t channel, + HAL_NotifyCallback callback, + void* param, + HAL_Bool initialNotify); +typedef void (*FreeChannelCallbackFunc)(int32_t index, int32_t channel, + int32_t uid); +typedef int32_t (*RegisterCallbackNoIndexFunc)(HAL_NotifyCallback callback, + void* param, + HAL_Bool initialNotify); +typedef void (*FreeCallbackNoIndexFunc)(int32_t uid); + +SIM_JniHandle AllocateCallback(JNIEnv* env, jint index, jobject callback, + jboolean initialNotify, + RegisterCallbackFunc createCallback); +SIM_JniHandle AllocateChannelCallback( + JNIEnv* env, jint index, jint channel, jobject callback, + jboolean initialNotify, RegisterChannelCallbackFunc createCallback); +SIM_JniHandle AllocateCallbackNoIndex( + JNIEnv* env, jobject callback, jboolean initialNotify, + RegisterCallbackNoIndexFunc createCallback); +void FreeCallback(JNIEnv* env, SIM_JniHandle handle, jint index, + FreeCallbackFunc freeCallback); +void FreeChannelCallback(JNIEnv* env, SIM_JniHandle handle, jint index, + jint channel, FreeChannelCallbackFunc freeCallback); +void FreeCallbackNoIndex(JNIEnv* env, SIM_JniHandle handle, + FreeCallbackNoIndexFunc freeCallback); +} // namespace sim diff --git a/hal/src/main/native/sim/jni/ConstBufferCallbackStore.cpp b/hal/src/main/native/sim/jni/ConstBufferCallbackStore.cpp new file mode 100644 index 0000000000..f3d47cf798 --- /dev/null +++ b/hal/src/main/native/sim/jni/ConstBufferCallbackStore.cpp @@ -0,0 +1,116 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#include "ConstBufferCallbackStore.h" + +#include +#include + +#include "HAL/Types.h" +#include "HAL/handles/UnlimitedHandleResource.h" +#include "MockData/HAL_Value.h" +#include "MockData/NotifyListener.h" +#include "SimulatorJNI.h" + +using namespace wpi::java; +using namespace sim; + +static hal::UnlimitedHandleResource* + callbackHandles; + +namespace sim { +void InitializeConstBufferStore() { + static hal::UnlimitedHandleResource + cb; + callbackHandles = &cb; +} +} // namespace sim + +void ConstBufferCallbackStore::create(JNIEnv* env, jobject obj) { + m_call = JGlobal(env, obj); +} + +void ConstBufferCallbackStore::performCallback(const char* name, + const uint8_t* buffer, + uint32_t length) { + JNIEnv* env; + JavaVM* vm = sim::GetJVM(); + bool didAttachThread = false; + int tryGetEnv = vm->GetEnv(reinterpret_cast(&env), JNI_VERSION_1_6); + if (tryGetEnv == JNI_EDETACHED) { + // Thread not attached + didAttachThread = true; + if (vm->AttachCurrentThread(reinterpret_cast(&env), nullptr) != 0) { + // Failed to attach, log and return + wpi::outs() << "Failed to attach\n"; + wpi::outs().flush(); + return; + } + } else if (tryGetEnv == JNI_EVERSION) { + wpi::outs() << "Invalid JVM Version requested\n"; + wpi::outs().flush(); + } + + auto toCallbackArr = + MakeJByteArray(env, wpi::StringRef{reinterpret_cast(buffer), + static_cast(length)}); + + env->CallVoidMethod(m_call, sim::GetConstBufferCallback(), + MakeJString(env, name), toCallbackArr, (jint)length); + + if (env->ExceptionCheck()) { + env->ExceptionDescribe(); + } + + if (didAttachThread) { + vm->DetachCurrentThread(); + } +} + +void ConstBufferCallbackStore::free(JNIEnv* env) { m_call.free(env); } + +SIM_JniHandle sim::AllocateConstBufferCallback( + JNIEnv* env, jint index, jobject callback, + RegisterConstBufferCallbackFunc createCallback) { + auto callbackStore = std::make_shared(); + + auto handle = callbackHandles->Allocate(callbackStore); + + if (handle == HAL_kInvalidHandle) { + return -1; + } + + uintptr_t handleAsPtr = static_cast(handle); + void* handleAsVoidPtr = reinterpret_cast(handleAsPtr); + + callbackStore->create(env, callback); + + auto callbackFunc = [](const char* name, void* param, const uint8_t* buffer, + uint32_t length) { + uintptr_t handleTmp = reinterpret_cast(param); + SIM_JniHandle handle = static_cast(handleTmp); + auto data = callbackHandles->Get(handle); + if (!data) return; + + data->performCallback(name, buffer, length); + }; + + auto id = createCallback(index, callbackFunc, handleAsVoidPtr); + + callbackStore->setCallbackId(id); + + return handle; +} + +void sim::FreeConstBufferCallback(JNIEnv* env, SIM_JniHandle handle, jint index, + FreeConstBufferCallbackFunc freeCallback) { + auto callback = callbackHandles->Free(handle); + freeCallback(index, callback->getCallbackId()); + callback->free(env); +} diff --git a/hal/src/main/native/sim/jni/ConstBufferCallbackStore.h b/hal/src/main/native/sim/jni/ConstBufferCallbackStore.h new file mode 100644 index 0000000000..e41ba33012 --- /dev/null +++ b/hal/src/main/native/sim/jni/ConstBufferCallbackStore.h @@ -0,0 +1,45 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#pragma once + +#include +#include + +#include "HAL/Types.h" +#include "HAL/handles/UnlimitedHandleResource.h" +#include "MockData/HAL_Value.h" +#include "MockData/NotifyListener.h" +#include "SimulatorJNI.h" + +namespace sim { +class ConstBufferCallbackStore { + public: + void create(JNIEnv* env, jobject obj); + void performCallback(const char* name, const uint8_t* buffer, + uint32_t length); + void free(JNIEnv* env); + void setCallbackId(int32_t id) { callbackId = id; } + int32_t getCallbackId() { return callbackId; } + + private: + wpi::java::JGlobal m_call; + int32_t callbackId; +}; + +void InitializeConstBufferStore(); + +typedef int32_t (*RegisterConstBufferCallbackFunc)( + int32_t index, HAL_ConstBufferCallback callback, void* param); +typedef void (*FreeConstBufferCallbackFunc)(int32_t index, int32_t uid); + +SIM_JniHandle AllocateConstBufferCallback( + JNIEnv* env, jint index, jobject callback, + RegisterConstBufferCallbackFunc createCallback); +void FreeConstBufferCallback(JNIEnv* env, SIM_JniHandle handle, jint index, + FreeConstBufferCallbackFunc freeCallback); +} // namespace sim diff --git a/hal/src/main/native/sim/jni/DIODataJNI.cpp b/hal/src/main/native/sim/jni/DIODataJNI.cpp new file mode 100644 index 0000000000..5f198e5f0a --- /dev/null +++ b/hal/src/main/native/sim/jni/DIODataJNI.cpp @@ -0,0 +1,153 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#include + +#include "CallbackStore.h" +#include "MockData/DIOData.h" +#include "edu_wpi_first_hal_sim_mockdata_DIODataJNI.h" + +extern "C" { + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_registerInitializedCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterDIOInitializedCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_cancelInitializedCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelDIOInitializedCallback); +} + +JNIEXPORT jboolean JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_getInitialized(JNIEnv*, jclass, + jint index) { + return HALSIM_GetDIOInitialized(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_setInitialized(JNIEnv*, jclass, + jint index, + jboolean value) { + HALSIM_SetDIOInitialized(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_registerValueCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterDIOValueCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_cancelValueCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, &HALSIM_CancelDIOValueCallback); +} + +JNIEXPORT jboolean JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_getValue(JNIEnv*, jclass, + jint index) { + return HALSIM_GetDIOValue(index); +} + +JNIEXPORT void JNICALL Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_setValue( + JNIEnv*, jclass, jint index, jboolean value) { + HALSIM_SetDIOValue(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_registerPulseLengthCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterDIOPulseLengthCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_cancelPulseLengthCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelDIOPulseLengthCallback); +} + +JNIEXPORT jdouble JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_getPulseLength(JNIEnv*, jclass, + jint index) { + return HALSIM_GetDIOPulseLength(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_setPulseLength(JNIEnv*, jclass, + jint index, + jdouble value) { + HALSIM_SetDIOPulseLength(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_registerIsInputCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterDIOIsInputCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_cancelIsInputCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelDIOIsInputCallback); +} + +JNIEXPORT jboolean JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_getIsInput(JNIEnv*, jclass, + jint index) { + return HALSIM_GetDIOIsInput(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_setIsInput(JNIEnv*, jclass, + jint index, + jboolean value) { + HALSIM_SetDIOIsInput(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_registerFilterIndexCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterDIOFilterIndexCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_cancelFilterIndexCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelDIOFilterIndexCallback); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_getFilterIndex(JNIEnv*, jclass, + jint index) { + return HALSIM_GetDIOFilterIndex(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_setFilterIndex(JNIEnv*, jclass, + jint index, + jint value) { + HALSIM_SetDIOFilterIndex(index, value); +} + +JNIEXPORT void JNICALL Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_resetData( + JNIEnv*, jclass, jint index) { + HALSIM_ResetDIOData(index); +} + +} // extern "C" diff --git a/hal/src/main/native/sim/jni/DigitalPWMDataJNI.cpp b/hal/src/main/native/sim/jni/DigitalPWMDataJNI.cpp new file mode 100644 index 0000000000..6903e12981 --- /dev/null +++ b/hal/src/main/native/sim/jni/DigitalPWMDataJNI.cpp @@ -0,0 +1,102 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#include + +#include "CallbackStore.h" +#include "MockData/DigitalPWMData.h" +#include "edu_wpi_first_hal_sim_mockdata_DigitalPWMDataJNI.h" + +extern "C" { + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DigitalPWMDataJNI_registerInitializedCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterDigitalPWMInitializedCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DigitalPWMDataJNI_cancelInitializedCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelDigitalPWMInitializedCallback); +} + +JNIEXPORT jboolean JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DigitalPWMDataJNI_getInitialized( + JNIEnv*, jclass, jint index) { + return HALSIM_GetDigitalPWMInitialized(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DigitalPWMDataJNI_setInitialized( + JNIEnv*, jclass, jint index, jboolean value) { + HALSIM_SetDigitalPWMInitialized(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DigitalPWMDataJNI_registerDutyCycleCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterDigitalPWMDutyCycleCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DigitalPWMDataJNI_cancelDutyCycleCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelDigitalPWMDutyCycleCallback); +} + +JNIEXPORT jdouble JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DigitalPWMDataJNI_getDutyCycle(JNIEnv*, + jclass, + jint index) { + return HALSIM_GetDigitalPWMDutyCycle(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DigitalPWMDataJNI_setDutyCycle( + JNIEnv*, jclass, jint index, jdouble value) { + HALSIM_SetDigitalPWMDutyCycle(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DigitalPWMDataJNI_registerPinCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterDigitalPWMPinCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DigitalPWMDataJNI_cancelPinCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelDigitalPWMPinCallback); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DigitalPWMDataJNI_getPin(JNIEnv*, jclass, + jint index) { + return HALSIM_GetDigitalPWMPin(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DigitalPWMDataJNI_setPin(JNIEnv*, jclass, + jint index, + jint value) { + HALSIM_SetDigitalPWMPin(index, value); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DigitalPWMDataJNI_resetData(JNIEnv*, jclass, + jint index) { + HALSIM_ResetDigitalPWMData(index); +} + +} // extern "C" diff --git a/hal/src/main/native/sim/jni/DriverStationDataJNI.cpp b/hal/src/main/native/sim/jni/DriverStationDataJNI.cpp new file mode 100644 index 0000000000..90a5cf9abd --- /dev/null +++ b/hal/src/main/native/sim/jni/DriverStationDataJNI.cpp @@ -0,0 +1,283 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#include + +#include "CallbackStore.h" +#include "MockData/DriverStationData.h" +#include "edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI.h" + +extern "C" { + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_registerEnabledCallback( + JNIEnv* env, jclass, jobject callback, jboolean initialNotify) { + return sim::AllocateCallbackNoIndex( + env, callback, initialNotify, + &HALSIM_RegisterDriverStationEnabledCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_cancelEnabledCallback( + JNIEnv* env, jclass, jint handle) { + return sim::FreeCallbackNoIndex(env, handle, + &HALSIM_CancelDriverStationEnabledCallback); +} + +JNIEXPORT jboolean JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_getEnabled(JNIEnv*, + jclass) { + return HALSIM_GetDriverStationEnabled(); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_setEnabled( + JNIEnv*, jclass, jboolean value) { + HALSIM_SetDriverStationEnabled(value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_registerAutonomousCallback( + JNIEnv* env, jclass, jobject callback, jboolean initialNotify) { + return sim::AllocateCallbackNoIndex( + env, callback, initialNotify, + &HALSIM_RegisterDriverStationAutonomousCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_cancelAutonomousCallback( + JNIEnv* env, jclass, jint handle) { + return sim::FreeCallbackNoIndex( + env, handle, &HALSIM_CancelDriverStationAutonomousCallback); +} + +JNIEXPORT jboolean JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_getAutonomous(JNIEnv*, + jclass) { + return HALSIM_GetDriverStationAutonomous(); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_setAutonomous( + JNIEnv*, jclass, jboolean value) { + HALSIM_SetDriverStationAutonomous(value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_registerTestCallback( + JNIEnv* env, jclass, jobject callback, jboolean initialNotify) { + return sim::AllocateCallbackNoIndex( + env, callback, initialNotify, &HALSIM_RegisterDriverStationTestCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_cancelTestCallback( + JNIEnv* env, jclass, jint handle) { + return sim::FreeCallbackNoIndex(env, handle, + &HALSIM_CancelDriverStationTestCallback); +} + +JNIEXPORT jboolean JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_getTest(JNIEnv*, + jclass) { + return HALSIM_GetDriverStationTest(); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_setTest( + JNIEnv*, jclass, jboolean value) { + HALSIM_SetDriverStationTest(value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_registerEStopCallback( + JNIEnv* env, jclass, jobject callback, jboolean initialNotify) { + return sim::AllocateCallbackNoIndex( + env, callback, initialNotify, &HALSIM_RegisterDriverStationEStopCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_cancelEStopCallback( + JNIEnv* env, jclass, jint handle) { + return sim::FreeCallbackNoIndex(env, handle, + &HALSIM_CancelDriverStationEStopCallback); +} + +JNIEXPORT jboolean JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_getEStop(JNIEnv*, + jclass) { + return HALSIM_GetDriverStationEStop(); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_setEStop( + JNIEnv*, jclass, jboolean value) { + HALSIM_SetDriverStationEStop(value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_registerFmsAttachedCallback( + JNIEnv* env, jclass, jobject callback, jboolean initialNotify) { + return sim::AllocateCallbackNoIndex( + env, callback, initialNotify, + &HALSIM_RegisterDriverStationFmsAttachedCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_cancelFmsAttachedCallback( + JNIEnv* env, jclass, jint handle) { + return sim::FreeCallbackNoIndex( + env, handle, &HALSIM_CancelDriverStationFmsAttachedCallback); +} + +JNIEXPORT jboolean JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_getFmsAttached( + JNIEnv*, jclass) { + return HALSIM_GetDriverStationFmsAttached(); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_setFmsAttached( + JNIEnv*, jclass, jboolean value) { + HALSIM_SetDriverStationFmsAttached(value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_registerDsAttachedCallback( + JNIEnv* env, jclass, jobject callback, jboolean initialNotify) { + return sim::AllocateCallbackNoIndex( + env, callback, initialNotify, + &HALSIM_RegisterDriverStationDsAttachedCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_cancelDsAttachedCallback( + JNIEnv* env, jclass, jint handle) { + return sim::FreeCallbackNoIndex( + env, handle, &HALSIM_CancelDriverStationDsAttachedCallback); +} + +JNIEXPORT jboolean JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_getDsAttached(JNIEnv*, + jclass) { + return HALSIM_GetDriverStationDsAttached(); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_setDsAttached( + JNIEnv*, jclass, jboolean value) { + HALSIM_SetDriverStationDsAttached(value); +} + +/* + * Class: edu_wpi_first_hal_sim_mockdata_DriverStationSim + * Method: setJoystickAxes + * Signature: (B[F)V + */ +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_setJoystickAxes( + JNIEnv* env, jclass, jbyte joystickNum, jfloatArray axesArray) { + HAL_JoystickAxes axes; + { + wpi::java::JFloatArrayRef jArrayRef(env, axesArray); + auto arrayRef = jArrayRef.array(); + auto arraySize = arrayRef.size(); + int maxCount = + arraySize < HAL_kMaxJoystickAxes ? arraySize : HAL_kMaxJoystickAxes; + axes.count = maxCount; + for (int i = 0; i < maxCount; i++) { + axes.axes[i] = arrayRef[i]; + } + } + HALSIM_SetJoystickAxes(joystickNum, &axes); + return; +} + +/* + * Class: edu_wpi_first_hal_sim_mockdata_DriverStationSim + * Method: setJoystickPOVs + * Signature: (B[S)V + */ +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_setJoystickPOVs( + JNIEnv* env, jclass, jbyte joystickNum, jshortArray povsArray) { + HAL_JoystickPOVs povs; + { + wpi::java::JShortArrayRef jArrayRef(env, povsArray); + auto arrayRef = jArrayRef.array(); + auto arraySize = arrayRef.size(); + int maxCount = + arraySize < HAL_kMaxJoystickPOVs ? arraySize : HAL_kMaxJoystickPOVs; + povs.count = maxCount; + for (int i = 0; i < maxCount; i++) { + povs.povs[i] = arrayRef[i]; + } + } + HALSIM_SetJoystickPOVs(joystickNum, &povs); + return; +} + +/* + * Class: edu_wpi_first_hal_sim_mockdata_DriverStationSim + * Method: setJoystickButtons + * Signature: (BII)V + */ +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_setJoystickButtons( + JNIEnv* env, jclass, jbyte joystickNum, jint buttons, jint count) { + if (count > 32) { + count = 32; + } + HAL_JoystickButtons joystickButtons; + joystickButtons.count = count; + joystickButtons.buttons = buttons; + HALSIM_SetJoystickButtons(joystickNum, &joystickButtons); +} + +/* + * Class: edu_wpi_first_hal_sim_mockdata_DriverStationSim + * Method: setMatchInfo + * Signature: (Ledu/wpi/first/wpilibj/hal/MatchInfoData;)V + */ +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_setMatchInfo( + JNIEnv* env, jclass, jobject info) {} + +/* + * Class: edu_wpi_first_hal_sim_mockdata_DriverStationSim + * Method: registerAllCallbacks + * Signature: (Ledu/wpi/first/hal/sim/NotifyCallback;Z)V + */ +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_registerAllCallbacks( + JNIEnv* env, jclass, jobject callback, jboolean initialNotify) { + sim::AllocateCallbackNoIndex( + env, callback, initialNotify, + [](HAL_NotifyCallback cb, void* param, HAL_Bool in) { + HALSIM_RegisterDriverStationAllCallbacks(cb, param, in); + return 0; + }); +} + +/* + * Class: edu_wpi_first_hal_sim_mockdata_DriverStationSim + * Method: notifyNewData + * Signature: ()V + */ +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_notifyNewData(JNIEnv*, + jclass) { + HALSIM_NotifyDriverStationNewData(); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_resetData(JNIEnv*, + jclass) { + HALSIM_ResetDriverStationData(); +} + +} // extern "C" diff --git a/hal/src/main/native/sim/jni/EncoderDataJNI.cpp b/hal/src/main/native/sim/jni/EncoderDataJNI.cpp new file mode 100644 index 0000000000..269c3f000d --- /dev/null +++ b/hal/src/main/native/sim/jni/EncoderDataJNI.cpp @@ -0,0 +1,235 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#include + +#include "CallbackStore.h" +#include "MockData/EncoderData.h" +#include "edu_wpi_first_hal_sim_mockdata_EncoderDataJNI.h" + +extern "C" { + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_registerInitializedCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterEncoderInitializedCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_cancelInitializedCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelEncoderInitializedCallback); +} + +JNIEXPORT jboolean JNICALL +Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_getInitialized(JNIEnv*, + jclass, + jint index) { + return HALSIM_GetEncoderInitialized(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_setInitialized( + JNIEnv*, jclass, jint index, jboolean value) { + HALSIM_SetEncoderInitialized(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_registerCountCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterEncoderCountCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_cancelCountCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelEncoderCountCallback); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_getCount(JNIEnv*, jclass, + jint index) { + return HALSIM_GetEncoderCount(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_setCount(JNIEnv*, jclass, + jint index, + jint value) { + HALSIM_SetEncoderCount(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_registerPeriodCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterEncoderPeriodCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_cancelPeriodCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelEncoderPeriodCallback); +} + +JNIEXPORT jdouble JNICALL +Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_getPeriod(JNIEnv*, jclass, + jint index) { + return HALSIM_GetEncoderPeriod(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_setPeriod(JNIEnv*, jclass, + jint index, + jdouble value) { + HALSIM_SetEncoderPeriod(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_registerResetCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterEncoderResetCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_cancelResetCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelEncoderResetCallback); +} + +JNIEXPORT jboolean JNICALL +Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_getReset(JNIEnv*, jclass, + jint index) { + return HALSIM_GetEncoderReset(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_setReset(JNIEnv*, jclass, + jint index, + jboolean value) { + HALSIM_SetEncoderReset(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_registerMaxPeriodCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterEncoderMaxPeriodCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_cancelMaxPeriodCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelEncoderMaxPeriodCallback); +} + +JNIEXPORT jdouble JNICALL +Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_getMaxPeriod(JNIEnv*, jclass, + jint index) { + return HALSIM_GetEncoderMaxPeriod(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_setMaxPeriod(JNIEnv*, jclass, + jint index, + jdouble value) { + HALSIM_SetEncoderMaxPeriod(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_registerDirectionCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterEncoderDirectionCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_cancelDirectionCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelEncoderDirectionCallback); +} + +JNIEXPORT jboolean JNICALL +Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_getDirection(JNIEnv*, jclass, + jint index) { + return HALSIM_GetEncoderDirection(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_setDirection( + JNIEnv*, jclass, jint index, jboolean value) { + HALSIM_SetEncoderDirection(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_registerReverseDirectionCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterEncoderReverseDirectionCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_cancelReverseDirectionCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelEncoderReverseDirectionCallback); +} + +JNIEXPORT jboolean JNICALL +Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_getReverseDirection( + JNIEnv*, jclass, jint index) { + return HALSIM_GetEncoderReverseDirection(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_setReverseDirection( + JNIEnv*, jclass, jint index, jboolean value) { + HALSIM_SetEncoderReverseDirection(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_registerSamplesToAverageCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterEncoderSamplesToAverageCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_cancelSamplesToAverageCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelEncoderSamplesToAverageCallback); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_getSamplesToAverage( + JNIEnv*, jclass, jint index) { + return HALSIM_GetEncoderSamplesToAverage(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_setSamplesToAverage( + JNIEnv*, jclass, jint index, jint value) { + HALSIM_SetEncoderSamplesToAverage(index, value); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_resetData(JNIEnv*, jclass, + jint index) { + HALSIM_ResetEncoderData(index); +} + +} // extern "C" diff --git a/hal/src/main/native/sim/jni/I2CDataJNI.cpp b/hal/src/main/native/sim/jni/I2CDataJNI.cpp new file mode 100644 index 0000000000..3531cdd7fa --- /dev/null +++ b/hal/src/main/native/sim/jni/I2CDataJNI.cpp @@ -0,0 +1,124 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#include + +#include "BufferCallbackStore.h" +#include "CallbackStore.h" +#include "ConstBufferCallbackStore.h" +#include "MockData/I2CData.h" +#include "edu_wpi_first_hal_sim_mockdata_I2CDataJNI.h" + +extern "C" { + +/* + * Class: edu_wpi_first_hal_sim_mockdata_I2CSim + * Method: registerInitializedCallback + * Signature: (ILedu/wpi/first/hal/sim/NotifyCallback;Z)I + */ +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_I2CDataJNI_registerInitializedCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterI2CInitializedCallback); +} + +/* + * Class: edu_wpi_first_hal_sim_mockdata_I2CSim + * Method: cancelInitializedCallback + * Signature: (II)V + */ +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_I2CDataJNI_cancelInitializedCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelI2CInitializedCallback); +} + +/* + * Class: edu_wpi_first_hal_sim_mockdata_I2CSim + * Method: getInitialized + * Signature: (I)Z + */ +JNIEXPORT jboolean JNICALL +Java_edu_wpi_first_hal_sim_mockdata_I2CDataJNI_getInitialized(JNIEnv*, jclass, + jint index) { + return HALSIM_GetI2CInitialized(index); +} + +/* + * Class: edu_wpi_first_hal_sim_mockdata_I2CSim + * Method: setInitialized + * Signature: (IZ)V + */ +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_I2CDataJNI_setInitialized(JNIEnv*, jclass, + jint index, + jboolean value) { + HALSIM_SetI2CInitialized(index, value); +} + +/* + * Class: edu_wpi_first_hal_sim_mockdata_I2CSim + * Method: registerReadCallback + * Signature: (ILedu/wpi/first/hal/sim/BufferCallback;)I + */ +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_I2CDataJNI_registerReadCallback( + JNIEnv* env, jclass, jint index, jobject callback) { + return sim::AllocateBufferCallback(env, index, callback, + &HALSIM_RegisterI2CReadCallback); +} + +/* + * Class: edu_wpi_first_hal_sim_mockdata_I2CSim + * Method: cancelReadCallback + * Signature: (II)V + */ +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_I2CDataJNI_cancelReadCallback(JNIEnv* env, + jclass, + jint index, + jint handle) { + sim::FreeBufferCallback(env, handle, index, &HALSIM_CancelI2CReadCallback); +} + +/* + * Class: edu_wpi_first_hal_sim_mockdata_I2CSim + * Method: registerWriteCallback + * Signature: (ILedu/wpi/first/hal/sim/ConstBufferCallback;)I + */ +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_I2CDataJNI_registerWriteCallback( + JNIEnv* env, jclass, jint index, jobject callback) { + return sim::AllocateConstBufferCallback(env, index, callback, + &HALSIM_RegisterI2CWriteCallback); +} + +/* + * Class: edu_wpi_first_hal_sim_mockdata_I2CSim + * Method: cancelWriteCallback + * Signature: (II)V + */ +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_I2CDataJNI_cancelWriteCallback( + JNIEnv* env, jclass, jint index, jint handle) { + sim::FreeConstBufferCallback(env, handle, index, + &HALSIM_CancelI2CWriteCallback); +} + +/* + * Class: edu_wpi_first_hal_sim_mockdata_I2CSim + * Method: resetData + * Signature: (I)V + */ +JNIEXPORT void JNICALL Java_edu_wpi_first_hal_sim_mockdata_I2CDataJNI_resetData( + JNIEnv*, jclass, jint index) { + HALSIM_ResetI2CData(index); +} + +} // extern "C" diff --git a/hal/src/main/native/sim/jni/PCMDataJNI.cpp b/hal/src/main/native/sim/jni/PCMDataJNI.cpp new file mode 100644 index 0000000000..29f5570b3e --- /dev/null +++ b/hal/src/main/native/sim/jni/PCMDataJNI.cpp @@ -0,0 +1,246 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#include + +#include "CallbackStore.h" +#include "MockData/PCMData.h" +#include "edu_wpi_first_hal_sim_mockdata_PCMDataJNI.h" + +extern "C" { + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_registerSolenoidInitializedCallback( + JNIEnv* env, jclass, jint index, jint channel, jobject callback, + jboolean initialNotify) { + return sim::AllocateChannelCallback( + env, index, channel, callback, initialNotify, + &HALSIM_RegisterPCMSolenoidInitializedCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_cancelSolenoidInitializedCallback( + JNIEnv* env, jclass, jint index, jint channel, jint handle) { + return sim::FreeChannelCallback(env, handle, index, channel, + &HALSIM_CancelPCMSolenoidInitializedCallback); +} + +JNIEXPORT jboolean JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_getSolenoidInitialized( + JNIEnv*, jclass, jint index, jint channel) { + return HALSIM_GetPCMSolenoidInitialized(index, channel); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_setSolenoidInitialized( + JNIEnv*, jclass, jint index, jint channel, jboolean value) { + HALSIM_SetPCMSolenoidInitialized(index, channel, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_registerSolenoidOutputCallback( + JNIEnv* env, jclass, jint index, jint channel, jobject callback, + jboolean initialNotify) { + return sim::AllocateChannelCallback( + env, index, channel, callback, initialNotify, + &HALSIM_RegisterPCMSolenoidOutputCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_cancelSolenoidOutputCallback( + JNIEnv* env, jclass, jint index, jint channel, jint handle) { + return sim::FreeChannelCallback(env, handle, index, channel, + &HALSIM_CancelPCMSolenoidOutputCallback); +} + +JNIEXPORT jboolean JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_getSolenoidOutput(JNIEnv*, + jclass, + jint index, + jint channel) { + return HALSIM_GetPCMSolenoidOutput(index, channel); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_setSolenoidOutput( + JNIEnv*, jclass, jint index, jint channel, jboolean value) { + HALSIM_SetPCMSolenoidOutput(index, channel, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_registerCompressorInitializedCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback( + env, index, callback, initialNotify, + &HALSIM_RegisterPCMCompressorInitializedCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_cancelCompressorInitializedCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelPCMCompressorInitializedCallback); +} + +JNIEXPORT jboolean JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_getCompressorInitialized( + JNIEnv*, jclass, jint index) { + return HALSIM_GetPCMCompressorInitialized(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_setCompressorInitialized( + JNIEnv*, jclass, jint index, jboolean value) { + HALSIM_SetPCMCompressorInitialized(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_registerCompressorOnCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterPCMCompressorOnCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_cancelCompressorOnCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelPCMCompressorOnCallback); +} + +JNIEXPORT jboolean JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_getCompressorOn(JNIEnv*, jclass, + jint index) { + return HALSIM_GetPCMCompressorOn(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_setCompressorOn(JNIEnv*, jclass, + jint index, + jboolean value) { + HALSIM_SetPCMCompressorOn(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_registerClosedLoopEnabledCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterPCMClosedLoopEnabledCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_cancelClosedLoopEnabledCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelPCMClosedLoopEnabledCallback); +} + +JNIEXPORT jboolean JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_getClosedLoopEnabled( + JNIEnv*, jclass, jint index) { + return HALSIM_GetPCMClosedLoopEnabled(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_setClosedLoopEnabled( + JNIEnv*, jclass, jint index, jboolean value) { + HALSIM_SetPCMClosedLoopEnabled(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_registerPressureSwitchCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterPCMPressureSwitchCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_cancelPressureSwitchCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelPCMPressureSwitchCallback); +} + +JNIEXPORT jboolean JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_getPressureSwitch(JNIEnv*, + jclass, + jint index) { + return HALSIM_GetPCMPressureSwitch(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_setPressureSwitch( + JNIEnv*, jclass, jint index, jboolean value) { + HALSIM_SetPCMPressureSwitch(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_registerCompressorCurrentCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterPCMCompressorCurrentCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_cancelCompressorCurrentCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelPCMCompressorCurrentCallback); +} + +JNIEXPORT jdouble JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_getCompressorCurrent( + JNIEnv*, jclass, jint index) { + return HALSIM_GetPCMCompressorCurrent(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_setCompressorCurrent( + JNIEnv*, jclass, jint index, jdouble value) { + HALSIM_SetPCMCompressorCurrent(index, value); +} + +/* + * Class: edu_wpi_first_hal_sim_mockdata_PCMSim + * Method: registerAllNonSolenoidCallbacks + * Signature: (ILedu/wpi/first/hal/sim/NotifyCallback;Z)V + */ +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_registerAllNonSolenoidCallbacks( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + sim::AllocateCallback( + env, index, callback, initialNotify, + [](int32_t index, HAL_NotifyCallback cb, void* param, HAL_Bool in) { + HALSIM_RegisterPCMAllNonSolenoidCallbacks(index, cb, param, in); + return 0; + }); +} + +/* + * Class: edu_wpi_first_hal_sim_mockdata_PCMSim + * Method: registerAllSolenoidCallbacks + * Signature: (IILedu/wpi/first/hal/sim/NotifyCallback;Z)V + */ +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_registerAllSolenoidCallbacks( + JNIEnv* env, jclass, jint index, jint channel, jobject callback, + jboolean initialNotify) { + sim::AllocateChannelCallback( + env, index, channel, callback, initialNotify, + [](int32_t index, int32_t channel, HAL_NotifyCallback cb, void* param, + HAL_Bool in) { + HALSIM_RegisterPCMAllSolenoidCallbacks(index, channel, cb, param, in); + return 0; + }); +} + +JNIEXPORT void JNICALL Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_resetData( + JNIEnv*, jclass, jint index) { + HALSIM_ResetPCMData(index); +} + +} // extern "C" diff --git a/hal/src/main/native/sim/jni/PDPDataJNI.cpp b/hal/src/main/native/sim/jni/PDPDataJNI.cpp new file mode 100644 index 0000000000..43c3ed40db --- /dev/null +++ b/hal/src/main/native/sim/jni/PDPDataJNI.cpp @@ -0,0 +1,133 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#include + +#include "CallbackStore.h" +#include "MockData/PDPData.h" +#include "edu_wpi_first_hal_sim_mockdata_PDPDataJNI.h" + +extern "C" { + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PDPDataJNI_registerInitializedCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterPDPInitializedCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PDPDataJNI_cancelInitializedCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelPDPInitializedCallback); +} + +JNIEXPORT jboolean JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PDPDataJNI_getInitialized(JNIEnv*, jclass, + jint index) { + return HALSIM_GetPDPInitialized(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PDPDataJNI_setInitialized(JNIEnv*, jclass, + jint index, + jboolean value) { + HALSIM_SetPDPInitialized(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PDPDataJNI_registerTemperatureCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterPDPTemperatureCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PDPDataJNI_cancelTemperatureCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelPDPTemperatureCallback); +} + +JNIEXPORT jdouble JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PDPDataJNI_getTemperature(JNIEnv*, jclass, + jint index) { + return HALSIM_GetPDPTemperature(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PDPDataJNI_setTemperature(JNIEnv*, jclass, + jint index, + jdouble value) { + HALSIM_SetPDPTemperature(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PDPDataJNI_registerVoltageCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterPDPVoltageCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PDPDataJNI_cancelVoltageCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelPDPVoltageCallback); +} + +JNIEXPORT jdouble JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PDPDataJNI_getVoltage(JNIEnv*, jclass, + jint index) { + return HALSIM_GetPDPVoltage(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PDPDataJNI_setVoltage(JNIEnv*, jclass, + jint index, + jdouble value) { + HALSIM_SetPDPVoltage(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PDPDataJNI_registerCurrentCallback( + JNIEnv* env, jclass, jint index, jint channel, jobject callback, + jboolean initialNotify) { + return sim::AllocateChannelCallback(env, index, channel, callback, + initialNotify, + &HALSIM_RegisterPDPCurrentCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PDPDataJNI_cancelCurrentCallback( + JNIEnv* env, jclass, jint index, jint channel, jint handle) { + return sim::FreeChannelCallback(env, handle, index, channel, + &HALSIM_CancelPDPCurrentCallback); +} + +JNIEXPORT jdouble JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PDPDataJNI_getCurrent(JNIEnv*, jclass, + jint index, + jint channel) { + return HALSIM_GetPDPCurrent(index, channel); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PDPDataJNI_setCurrent(JNIEnv*, jclass, + jint index, + jint channel, + jdouble value) { + HALSIM_SetPDPCurrent(index, channel, value); +} + +JNIEXPORT void JNICALL Java_edu_wpi_first_hal_sim_mockdata_PDPDataJNI_resetData( + JNIEnv*, jclass, jint index) { + HALSIM_ResetPDPData(index); +} + +} // extern "C" diff --git a/hal/src/main/native/sim/jni/PWMDataJNI.cpp b/hal/src/main/native/sim/jni/PWMDataJNI.cpp new file mode 100644 index 0000000000..2c4d261333 --- /dev/null +++ b/hal/src/main/native/sim/jni/PWMDataJNI.cpp @@ -0,0 +1,180 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#include + +#include "CallbackStore.h" +#include "MockData/PWMData.h" +#include "edu_wpi_first_hal_sim_mockdata_PWMDataJNI.h" + +extern "C" { + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_registerInitializedCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterPWMInitializedCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_cancelInitializedCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelPWMInitializedCallback); +} + +JNIEXPORT jboolean JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_getInitialized(JNIEnv*, jclass, + jint index) { + return HALSIM_GetPWMInitialized(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_setInitialized(JNIEnv*, jclass, + jint index, + jboolean value) { + HALSIM_SetPWMInitialized(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_registerRawValueCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterPWMRawValueCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_cancelRawValueCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelPWMRawValueCallback); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_getRawValue(JNIEnv*, jclass, + jint index) { + return HALSIM_GetPWMRawValue(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_setRawValue(JNIEnv*, jclass, + jint index, + jint value) { + HALSIM_SetPWMRawValue(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_registerSpeedCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterPWMSpeedCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_cancelSpeedCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, &HALSIM_CancelPWMSpeedCallback); +} + +JNIEXPORT jdouble JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_getSpeed(JNIEnv*, jclass, + jint index) { + return HALSIM_GetPWMSpeed(index); +} + +JNIEXPORT void JNICALL Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_setSpeed( + JNIEnv*, jclass, jint index, jdouble value) { + HALSIM_SetPWMSpeed(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_registerPositionCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterPWMPositionCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_cancelPositionCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelPWMPositionCallback); +} + +JNIEXPORT jdouble JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_getPosition(JNIEnv*, jclass, + jint index) { + return HALSIM_GetPWMPosition(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_setPosition(JNIEnv*, jclass, + jint index, + jdouble value) { + HALSIM_SetPWMPosition(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_registerPeriodScaleCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterPWMPeriodScaleCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_cancelPeriodScaleCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelPWMPeriodScaleCallback); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_getPeriodScale(JNIEnv*, jclass, + jint index) { + return HALSIM_GetPWMPeriodScale(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_setPeriodScale(JNIEnv*, jclass, + jint index, + jint value) { + HALSIM_SetPWMPeriodScale(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_registerZeroLatchCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterPWMZeroLatchCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_cancelZeroLatchCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelPWMZeroLatchCallback); +} + +JNIEXPORT jboolean JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_getZeroLatch(JNIEnv*, jclass, + jint index) { + return HALSIM_GetPWMZeroLatch(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_setZeroLatch(JNIEnv*, jclass, + jint index, + jboolean value) { + HALSIM_SetPWMZeroLatch(index, value); +} + +JNIEXPORT void JNICALL Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_resetData( + JNIEnv*, jclass, jint index) { + HALSIM_ResetPWMData(index); +} + +} // extern "C" diff --git a/hal/src/main/native/sim/jni/RelayDataJNI.cpp b/hal/src/main/native/sim/jni/RelayDataJNI.cpp new file mode 100644 index 0000000000..d6de1efdac --- /dev/null +++ b/hal/src/main/native/sim/jni/RelayDataJNI.cpp @@ -0,0 +1,128 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#include + +#include "CallbackStore.h" +#include "MockData/RelayData.h" +#include "edu_wpi_first_hal_sim_mockdata_RelayDataJNI.h" + +extern "C" { + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RelayDataJNI_registerInitializedForwardCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterRelayInitializedForwardCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RelayDataJNI_cancelInitializedForwardCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelRelayInitializedForwardCallback); +} + +JNIEXPORT jboolean JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RelayDataJNI_getInitializedForward( + JNIEnv*, jclass, jint index) { + return HALSIM_GetRelayInitializedForward(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RelayDataJNI_setInitializedForward( + JNIEnv*, jclass, jint index, jboolean value) { + HALSIM_SetRelayInitializedForward(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RelayDataJNI_registerInitializedReverseCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterRelayInitializedReverseCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RelayDataJNI_cancelInitializedReverseCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelRelayInitializedReverseCallback); +} + +JNIEXPORT jboolean JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RelayDataJNI_getInitializedReverse( + JNIEnv*, jclass, jint index) { + return HALSIM_GetRelayInitializedReverse(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RelayDataJNI_setInitializedReverse( + JNIEnv*, jclass, jint index, jboolean value) { + HALSIM_SetRelayInitializedReverse(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RelayDataJNI_registerForwardCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterRelayForwardCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RelayDataJNI_cancelForwardCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelRelayForwardCallback); +} + +JNIEXPORT jboolean JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RelayDataJNI_getForward(JNIEnv*, jclass, + jint index) { + return HALSIM_GetRelayForward(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RelayDataJNI_setForward(JNIEnv*, jclass, + jint index, + jboolean value) { + HALSIM_SetRelayForward(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RelayDataJNI_registerReverseCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterRelayReverseCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RelayDataJNI_cancelReverseCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelRelayReverseCallback); +} + +JNIEXPORT jboolean JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RelayDataJNI_getReverse(JNIEnv*, jclass, + jint index) { + return HALSIM_GetRelayReverse(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RelayDataJNI_setReverse(JNIEnv*, jclass, + jint index, + jboolean value) { + HALSIM_SetRelayReverse(index, value); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RelayDataJNI_resetData(JNIEnv*, jclass, + jint index) { + HALSIM_ResetRelayData(index); +} + +} // extern "C" diff --git a/hal/src/main/native/sim/jni/RoboRioDataJNI.cpp b/hal/src/main/native/sim/jni/RoboRioDataJNI.cpp new file mode 100644 index 0000000000..a22c315b5e --- /dev/null +++ b/hal/src/main/native/sim/jni/RoboRioDataJNI.cpp @@ -0,0 +1,423 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#include + +#include "CallbackStore.h" +#include "MockData/RoboRioData.h" +#include "edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI.h" + +extern "C" { + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_registerFPGAButtonCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterRoboRioFPGAButtonCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_cancelFPGAButtonCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelRoboRioFPGAButtonCallback); +} + +JNIEXPORT jboolean JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_getFPGAButton(JNIEnv*, + jclass, + jint index) { + return HALSIM_GetRoboRioFPGAButton(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_setFPGAButton( + JNIEnv*, jclass, jint index, jboolean value) { + HALSIM_SetRoboRioFPGAButton(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_registerVInVoltageCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterRoboRioVInVoltageCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_cancelVInVoltageCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelRoboRioVInVoltageCallback); +} + +JNIEXPORT jdouble JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_getVInVoltage(JNIEnv*, + jclass, + jint index) { + return HALSIM_GetRoboRioVInVoltage(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_setVInVoltage( + JNIEnv*, jclass, jint index, jdouble value) { + HALSIM_SetRoboRioVInVoltage(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_registerVInCurrentCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterRoboRioVInCurrentCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_cancelVInCurrentCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelRoboRioVInCurrentCallback); +} + +JNIEXPORT jdouble JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_getVInCurrent(JNIEnv*, + jclass, + jint index) { + return HALSIM_GetRoboRioVInCurrent(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_setVInCurrent( + JNIEnv*, jclass, jint index, jdouble value) { + HALSIM_SetRoboRioVInCurrent(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_registerUserVoltage6VCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterRoboRioUserVoltage6VCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_cancelUserVoltage6VCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelRoboRioUserVoltage6VCallback); +} + +JNIEXPORT jdouble JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_getUserVoltage6V( + JNIEnv*, jclass, jint index) { + return HALSIM_GetRoboRioUserVoltage6V(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_setUserVoltage6V( + JNIEnv*, jclass, jint index, jdouble value) { + HALSIM_SetRoboRioUserVoltage6V(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_registerUserCurrent6VCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterRoboRioUserCurrent6VCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_cancelUserCurrent6VCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelRoboRioUserCurrent6VCallback); +} + +JNIEXPORT jdouble JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_getUserCurrent6V( + JNIEnv*, jclass, jint index) { + return HALSIM_GetRoboRioUserCurrent6V(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_setUserCurrent6V( + JNIEnv*, jclass, jint index, jdouble value) { + HALSIM_SetRoboRioUserCurrent6V(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_registerUserActive6VCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterRoboRioUserActive6VCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_cancelUserActive6VCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelRoboRioUserActive6VCallback); +} + +JNIEXPORT jboolean JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_getUserActive6V(JNIEnv*, + jclass, + jint index) { + return HALSIM_GetRoboRioUserActive6V(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_setUserActive6V( + JNIEnv*, jclass, jint index, jboolean value) { + HALSIM_SetRoboRioUserActive6V(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_registerUserVoltage5VCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterRoboRioUserVoltage5VCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_cancelUserVoltage5VCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelRoboRioUserVoltage5VCallback); +} + +JNIEXPORT jdouble JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_getUserVoltage5V( + JNIEnv*, jclass, jint index) { + return HALSIM_GetRoboRioUserVoltage5V(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_setUserVoltage5V( + JNIEnv*, jclass, jint index, jdouble value) { + HALSIM_SetRoboRioUserVoltage5V(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_registerUserCurrent5VCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterRoboRioUserCurrent5VCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_cancelUserCurrent5VCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelRoboRioUserCurrent5VCallback); +} + +JNIEXPORT jdouble JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_getUserCurrent5V( + JNIEnv*, jclass, jint index) { + return HALSIM_GetRoboRioUserCurrent5V(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_setUserCurrent5V( + JNIEnv*, jclass, jint index, jdouble value) { + HALSIM_SetRoboRioUserCurrent5V(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_registerUserActive5VCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterRoboRioUserActive5VCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_cancelUserActive5VCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelRoboRioUserActive5VCallback); +} + +JNIEXPORT jboolean JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_getUserActive5V(JNIEnv*, + jclass, + jint index) { + return HALSIM_GetRoboRioUserActive5V(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_setUserActive5V( + JNIEnv*, jclass, jint index, jboolean value) { + HALSIM_SetRoboRioUserActive5V(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_registerUserVoltage3V3Callback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterRoboRioUserVoltage3V3Callback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_cancelUserVoltage3V3Callback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelRoboRioUserVoltage3V3Callback); +} + +JNIEXPORT jdouble JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_getUserVoltage3V3( + JNIEnv*, jclass, jint index) { + return HALSIM_GetRoboRioUserVoltage3V3(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_setUserVoltage3V3( + JNIEnv*, jclass, jint index, jdouble value) { + HALSIM_SetRoboRioUserVoltage3V3(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_registerUserCurrent3V3Callback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterRoboRioUserCurrent3V3Callback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_cancelUserCurrent3V3Callback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelRoboRioUserCurrent3V3Callback); +} + +JNIEXPORT jdouble JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_getUserCurrent3V3( + JNIEnv*, jclass, jint index) { + return HALSIM_GetRoboRioUserCurrent3V3(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_setUserCurrent3V3( + JNIEnv*, jclass, jint index, jdouble value) { + HALSIM_SetRoboRioUserCurrent3V3(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_registerUserActive3V3Callback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterRoboRioUserActive3V3Callback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_cancelUserActive3V3Callback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelRoboRioUserActive3V3Callback); +} + +JNIEXPORT jboolean JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_getUserActive3V3( + JNIEnv*, jclass, jint index) { + return HALSIM_GetRoboRioUserActive3V3(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_setUserActive3V3( + JNIEnv*, jclass, jint index, jboolean value) { + HALSIM_SetRoboRioUserActive3V3(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_registerUserFaults6VCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterRoboRioUserFaults6VCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_cancelUserFaults6VCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelRoboRioUserFaults6VCallback); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_getUserFaults6V(JNIEnv*, + jclass, + jint index) { + return HALSIM_GetRoboRioUserFaults6V(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_setUserFaults6V(JNIEnv*, + jclass, + jint index, + jint value) { + HALSIM_SetRoboRioUserFaults6V(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_registerUserFaults5VCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterRoboRioUserFaults5VCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_cancelUserFaults5VCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelRoboRioUserFaults5VCallback); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_getUserFaults5V(JNIEnv*, + jclass, + jint index) { + return HALSIM_GetRoboRioUserFaults5V(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_setUserFaults5V(JNIEnv*, + jclass, + jint index, + jint value) { + HALSIM_SetRoboRioUserFaults5V(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_registerUserFaults3V3Callback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterRoboRioUserFaults3V3Callback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_cancelUserFaults3V3Callback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelRoboRioUserFaults3V3Callback); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_getUserFaults3V3( + JNIEnv*, jclass, jint index) { + return HALSIM_GetRoboRioUserFaults3V3(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_setUserFaults3V3( + JNIEnv*, jclass, jint index, jint value) { + HALSIM_SetRoboRioUserFaults3V3(index, value); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_resetData(JNIEnv*, jclass, + jint index) { + HALSIM_ResetRoboRioData(index); +} + +} // extern "C" diff --git a/hal/src/main/native/sim/jni/SPIAccelerometerDataJNI.cpp b/hal/src/main/native/sim/jni/SPIAccelerometerDataJNI.cpp new file mode 100644 index 0000000000..64e3702968 --- /dev/null +++ b/hal/src/main/native/sim/jni/SPIAccelerometerDataJNI.cpp @@ -0,0 +1,155 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#include + +#include "CallbackStore.h" +#include "MockData/SPIAccelerometerData.h" +#include "edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI.h" + +extern "C" { + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_registerActiveCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterSPIAccelerometerActiveCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_cancelActiveCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelSPIAccelerometerActiveCallback); +} + +JNIEXPORT jboolean JNICALL +Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_getActive( + JNIEnv*, jclass, jint index) { + return HALSIM_GetSPIAccelerometerActive(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_setActive( + JNIEnv*, jclass, jint index, jboolean value) { + HALSIM_SetSPIAccelerometerActive(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_registerRangeCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterSPIAccelerometerRangeCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_cancelRangeCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelSPIAccelerometerRangeCallback); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_getRange( + JNIEnv*, jclass, jint index) { + return HALSIM_GetSPIAccelerometerRange(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_setRange( + JNIEnv*, jclass, jint index, jint value) { + HALSIM_SetSPIAccelerometerRange(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_registerXCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterSPIAccelerometerXCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_cancelXCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelSPIAccelerometerXCallback); +} + +JNIEXPORT jdouble JNICALL +Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_getX(JNIEnv*, + jclass, + jint index) { + return HALSIM_GetSPIAccelerometerX(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_setX( + JNIEnv*, jclass, jint index, jdouble value) { + HALSIM_SetSPIAccelerometerX(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_registerYCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterSPIAccelerometerYCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_cancelYCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelSPIAccelerometerYCallback); +} + +JNIEXPORT jdouble JNICALL +Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_getY(JNIEnv*, + jclass, + jint index) { + return HALSIM_GetSPIAccelerometerY(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_setY( + JNIEnv*, jclass, jint index, jdouble value) { + HALSIM_SetSPIAccelerometerY(index, value); +} + +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_registerZCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterSPIAccelerometerZCallback); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_cancelZCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelSPIAccelerometerZCallback); +} + +JNIEXPORT jdouble JNICALL +Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_getZ(JNIEnv*, + jclass, + jint index) { + return HALSIM_GetSPIAccelerometerZ(index); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_setZ( + JNIEnv*, jclass, jint index, jdouble value) { + HALSIM_SetSPIAccelerometerZ(index, value); +} + +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_resetData( + JNIEnv*, jclass, jint index) { + HALSIM_ResetSPIAccelerometerData(index); +} + +} // extern "C" diff --git a/hal/src/main/native/sim/jni/SPIDataJNI.cpp b/hal/src/main/native/sim/jni/SPIDataJNI.cpp new file mode 100644 index 0000000000..b5aa91175b --- /dev/null +++ b/hal/src/main/native/sim/jni/SPIDataJNI.cpp @@ -0,0 +1,149 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#include + +#include "BufferCallbackStore.h" +#include "CallbackStore.h" +#include "ConstBufferCallbackStore.h" +#include "MockData/SPIData.h" +#include "SpiReadAutoReceiveBufferCallbackStore.h" +#include "edu_wpi_first_hal_sim_mockdata_SPIDataJNI.h" + +extern "C" { + +/* + * Class: edu_wpi_first_hal_sim_mockdata_SPISim + * Method: registerInitializedCallback + * Signature: (ILedu/wpi/first/hal/sim/NotifyCallback;Z)I + */ +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_SPIDataJNI_registerInitializedCallback( + JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) { + return sim::AllocateCallback(env, index, callback, initialNotify, + &HALSIM_RegisterSPIInitializedCallback); +} + +/* + * Class: edu_wpi_first_hal_sim_mockdata_SPISim + * Method: cancelInitializedCallback + * Signature: (II)V + */ +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_SPIDataJNI_cancelInitializedCallback( + JNIEnv* env, jclass, jint index, jint handle) { + return sim::FreeCallback(env, handle, index, + &HALSIM_CancelSPIInitializedCallback); +} + +/* + * Class: edu_wpi_first_hal_sim_mockdata_SPISim + * Method: getInitialized + * Signature: (I)Z + */ +JNIEXPORT jboolean JNICALL +Java_edu_wpi_first_hal_sim_mockdata_SPIDataJNI_getInitialized(JNIEnv*, jclass, + jint index) { + return HALSIM_GetSPIInitialized(index); +} + +/* + * Class: edu_wpi_first_hal_sim_mockdata_SPISim + * Method: setInitialized + * Signature: (IZ)V + */ +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_SPIDataJNI_setInitialized(JNIEnv*, jclass, + jint index, + jboolean value) { + HALSIM_SetSPIInitialized(index, value); +} + +/* + * Class: edu_wpi_first_hal_sim_mockdata_SPISim + * Method: registerReadCallback + * Signature: (ILedu/wpi/first/hal/sim/BufferCallback;)I + */ +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_SPIDataJNI_registerReadCallback( + JNIEnv* env, jclass, jint index, jobject callback) { + return sim::AllocateBufferCallback(env, index, callback, + &HALSIM_RegisterSPIReadCallback); +} + +/* + * Class: edu_wpi_first_hal_sim_mockdata_SPISim + * Method: cancelReadCallback + * Signature: (II)V + */ +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_SPIDataJNI_cancelReadCallback(JNIEnv* env, + jclass, + jint index, + jint handle) { + sim::FreeBufferCallback(env, handle, index, &HALSIM_CancelSPIReadCallback); +} + +/* + * Class: edu_wpi_first_hal_sim_mockdata_SPISim + * Method: registerWriteCallback + * Signature: (ILedu/wpi/first/hal/sim/ConstBufferCallback;)I + */ +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_SPIDataJNI_registerWriteCallback( + JNIEnv* env, jclass, jint index, jobject callback) { + return sim::AllocateConstBufferCallback(env, index, callback, + &HALSIM_RegisterSPIWriteCallback); +} + +/* + * Class: edu_wpi_first_hal_sim_mockdata_SPISim + * Method: cancelWriteCallback + * Signature: (II)V + */ +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_SPIDataJNI_cancelWriteCallback( + JNIEnv* env, jclass, jint index, jint handle) { + sim::FreeConstBufferCallback(env, handle, index, + &HALSIM_CancelSPIWriteCallback); +} + +/* + * Class: edu_wpi_first_hal_sim_mockdata_SPISim + * Method: registerReadAutoReceiveBufferCallback + * Signature: (ILedu/wpi/first/hal/sim/SpiReadAutoReceiveBufferCallback;)I + */ +JNIEXPORT jint JNICALL +Java_edu_wpi_first_hal_sim_mockdata_SPIDataJNI_registerReadAutoReceiveBufferCallback( + JNIEnv* env, jclass, jint index, jobject callback) { + return sim::AllocateSpiBufferCallback( + env, index, callback, &HALSIM_RegisterSPIReadAutoReceivedDataCallback); +} + +/* + * Class: edu_wpi_first_hal_sim_mockdata_SPISim + * Method: cancelReadAutoReceiveBufferCallback + * Signature: (II)V + */ +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_SPIDataJNI_cancelReadAutoReceiveBufferCallback( + JNIEnv* env, jclass, jint index, jint handle) { + sim::FreeSpiBufferCallback(env, handle, index, + &HALSIM_CancelSPIReadAutoReceivedDataCallback); +} + +/* + * Class: edu_wpi_first_hal_sim_mockdata_SPISim + * Method: resetData + * Signature: (I)V + */ +JNIEXPORT void JNICALL Java_edu_wpi_first_hal_sim_mockdata_SPIDataJNI_resetData( + JNIEnv*, jclass, jint index) { + HALSIM_ResetSPIData(index); +} + +} // extern "C" diff --git a/hal/src/main/native/sim/jni/SimulatorJNI.cpp b/hal/src/main/native/sim/jni/SimulatorJNI.cpp new file mode 100644 index 0000000000..3b34b5ad0f --- /dev/null +++ b/hal/src/main/native/sim/jni/SimulatorJNI.cpp @@ -0,0 +1,151 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#include "BufferCallbackStore.h" +#include "CallbackStore.h" +#include "ConstBufferCallbackStore.h" +#include "HAL/HAL.h" +#include "HAL/cpp/Log.h" +#include "HAL/handles/HandlesInternal.h" +#include "MockData/MockHooks.h" +#include "SimulatorJNI.h" +#include "SpiReadAutoReceiveBufferCallbackStore.h" +#include "edu_wpi_first_hal_sim_mockdata_SimulatorJNI.h" + +using namespace wpi::java; + +static JavaVM* jvm = nullptr; +static JClass simValueCls; +static JClass notifyCallbackCls; +static JClass bufferCallbackCls; +static JClass constBufferCallbackCls; +static JClass spiReadAutoReceiveBufferCallbackCls; +static jmethodID notifyCallbackCallback; +static jmethodID bufferCallbackCallback; +static jmethodID constBufferCallbackCallback; +static jmethodID spiReadAutoReceiveBufferCallbackCallback; + +namespace sim { +jint SimOnLoad(JavaVM* vm, void* reserved) { + jvm = vm; + + JNIEnv* env; + if (vm->GetEnv(reinterpret_cast(&env), JNI_VERSION_1_6) != JNI_OK) + return JNI_ERR; + + simValueCls = JClass(env, "edu/wpi/first/wpilibj/sim/SimValue"); + if (!simValueCls) return JNI_ERR; + + notifyCallbackCls = JClass(env, "edu/wpi/first/wpilibj/sim/NotifyCallback"); + if (!notifyCallbackCls) return JNI_ERR; + + notifyCallbackCallback = env->GetMethodID(notifyCallbackCls, "callbackNative", + "(Ljava/lang/String;IJD)V"); + if (!notifyCallbackCallback) return JNI_ERR; + + bufferCallbackCls = JClass(env, "edu/wpi/first/wpilibj/sim/BufferCallback"); + if (!bufferCallbackCls) return JNI_ERR; + + bufferCallbackCallback = env->GetMethodID(bufferCallbackCls, "callback", + "(Ljava/lang/String;[BI)V"); + if (!bufferCallbackCallback) return JNI_ERR; + + constBufferCallbackCls = + JClass(env, "edu/wpi/first/wpilibj/sim/ConstBufferCallback"); + if (!constBufferCallbackCls) return JNI_ERR; + + constBufferCallbackCallback = env->GetMethodID( + constBufferCallbackCls, "callback", "(Ljava/lang/String;[BI)V"); + if (!constBufferCallbackCallback) return JNI_ERR; + + spiReadAutoReceiveBufferCallbackCls = + JClass(env, "edu/wpi/first/wpilibj/sim/SpiReadAutoReceiveBufferCallback"); + if (!spiReadAutoReceiveBufferCallbackCls) return JNI_ERR; + + spiReadAutoReceiveBufferCallbackCallback = + env->GetMethodID(spiReadAutoReceiveBufferCallbackCls, "callback", + "(Ljava/lang/String;[BI)I"); + if (!spiReadAutoReceiveBufferCallbackCallback) return JNI_ERR; + + InitializeStore(); + InitializeBufferStore(); + InitializeConstBufferStore(); + InitializeSpiBufferStore(); + + return JNI_VERSION_1_6; +} + +void SimOnUnload(JavaVM* vm, void* reserved) { + JNIEnv* env; + if (vm->GetEnv(reinterpret_cast(&env), JNI_VERSION_1_6) != JNI_OK) + return; + + simValueCls.free(env); + notifyCallbackCls.free(env); + bufferCallbackCls.free(env); + constBufferCallbackCls.free(env); + spiReadAutoReceiveBufferCallbackCls.free(env); + jvm = nullptr; +} + +JavaVM* GetJVM() { return jvm; } + +jmethodID GetNotifyCallback() { return notifyCallbackCallback; } + +jmethodID GetBufferCallback() { return bufferCallbackCallback; } + +jmethodID GetConstBufferCallback() { return constBufferCallbackCallback; } + +jmethodID GetSpiReadAutoReceiveBufferCallback() { + return spiReadAutoReceiveBufferCallbackCallback; +} +} // namespace sim + +extern "C" { +/* + * Class: edu_wpi_first_hal_sim_mockdata_SimulatorJNI + * Method: waitForProgramStart + * Signature: ()V + */ +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_SimulatorJNI_waitForProgramStart(JNIEnv*, + jclass) { + HALSIM_WaitForProgramStart(); +} + +/* + * Class: edu_wpi_first_hal_sim_mockdata_SimulatorJNI + * Method: setProgramStarted + * Signature: ()V + */ +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_SimulatorJNI_setProgramStarted(JNIEnv*, + jclass) { + HALSIM_SetProgramStarted(); +} + +/* + * Class: edu_wpi_first_hal_sim_mockdata_SimulatorJNI + * Method: restartTiming + * Signature: ()V + */ +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_SimulatorJNI_restartTiming(JNIEnv*, + jclass) { + HALSIM_RestartTiming(); +} + +/* + * Class: edu_wpi_first_hal_sim_mockdata_SimulatorJNI + * Method: resetHandles + * Signature: ()V + */ +JNIEXPORT void JNICALL +Java_edu_wpi_first_hal_sim_mockdata_SimulatorJNI_resetHandles(JNIEnv*, jclass) { + hal::HandleBase::ResetGlobalHandles(); +} +} // extern "C" diff --git a/hal/src/main/native/sim/jni/SimulatorJNI.h b/hal/src/main/native/sim/jni/SimulatorJNI.h new file mode 100644 index 0000000000..819783b570 --- /dev/null +++ b/hal/src/main/native/sim/jni/SimulatorJNI.h @@ -0,0 +1,25 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#pragma once + +#include + +#include "HAL/Types.h" +#include "MockData/HAL_Value.h" +#include "jni.h" + +typedef HAL_Handle SIM_JniHandle; + +namespace sim { +JavaVM* GetJVM(); + +jmethodID GetNotifyCallback(); +jmethodID GetBufferCallback(); +jmethodID GetConstBufferCallback(); +jmethodID GetSpiReadAutoReceiveBufferCallback(); +} // namespace sim diff --git a/hal/src/main/native/sim/jni/SpiReadAutoReceiveBufferCallbackStore.cpp b/hal/src/main/native/sim/jni/SpiReadAutoReceiveBufferCallbackStore.cpp new file mode 100644 index 0000000000..7b5d994318 --- /dev/null +++ b/hal/src/main/native/sim/jni/SpiReadAutoReceiveBufferCallbackStore.cpp @@ -0,0 +1,130 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#include "SpiReadAutoReceiveBufferCallbackStore.h" + +#include +#include + +#include "HAL/Types.h" +#include "HAL/handles/UnlimitedHandleResource.h" +#include "MockData/HAL_Value.h" +#include "MockData/NotifyListener.h" +#include "SimulatorJNI.h" + +using namespace wpi::java; +using namespace sim; + +static hal::UnlimitedHandleResource< + SIM_JniHandle, SpiReadAutoReceiveBufferCallbackStore, + hal::HAL_HandleEnum::SimulationJni>* callbackHandles; + +namespace sim { +void InitializeSpiBufferStore() { + static hal::UnlimitedHandleResource + cb; + callbackHandles = &cb; +} +} // namespace sim + +void SpiReadAutoReceiveBufferCallbackStore::create(JNIEnv* env, jobject obj) { + m_call = JGlobal(env, obj); +} + +int32_t SpiReadAutoReceiveBufferCallbackStore::performCallback( + const char* name, unsigned char* buffer, int32_t numToRead) { + JNIEnv* env; + JavaVM* vm = sim::GetJVM(); + bool didAttachThread = false; + int tryGetEnv = vm->GetEnv(reinterpret_cast(&env), JNI_VERSION_1_6); + if (tryGetEnv == JNI_EDETACHED) { + // Thread not attached + didAttachThread = true; + if (vm->AttachCurrentThread(reinterpret_cast(&env), nullptr) != 0) { + // Failed to attach, log and return + wpi::outs() << "Failed to attach\n"; + wpi::outs().flush(); + return -1; + } + } else if (tryGetEnv == JNI_EVERSION) { + wpi::outs() << "Invalid JVM Version requested\n"; + wpi::outs().flush(); + } + + auto toCallbackArr = + MakeJByteArray(env, wpi::StringRef{reinterpret_cast(buffer), + static_cast(numToRead)}); + + jint ret = env->CallIntMethod(m_call, sim::GetBufferCallback(), + MakeJString(env, name), toCallbackArr, + (jint)numToRead); + + jbyte* fromCallbackArr = reinterpret_cast( + env->GetPrimitiveArrayCritical(toCallbackArr, nullptr)); + + for (int i = 0; i < ret; i++) { + buffer[i] = fromCallbackArr[i]; + } + + env->ReleasePrimitiveArrayCritical(toCallbackArr, fromCallbackArr, JNI_ABORT); + + if (env->ExceptionCheck()) { + env->ExceptionDescribe(); + } + + if (didAttachThread) { + vm->DetachCurrentThread(); + } + return ret; +} + +void SpiReadAutoReceiveBufferCallbackStore::free(JNIEnv* env) { + m_call.free(env); +} + +SIM_JniHandle sim::AllocateSpiBufferCallback( + JNIEnv* env, jint index, jobject callback, + RegisterSpiBufferCallbackFunc createCallback) { + auto callbackStore = + std::make_shared(); + + auto handle = callbackHandles->Allocate(callbackStore); + + if (handle == HAL_kInvalidHandle) { + return -1; + } + + uintptr_t handleAsPtr = static_cast(handle); + void* handleAsVoidPtr = reinterpret_cast(handleAsPtr); + + callbackStore->create(env, callback); + + auto callbackFunc = [](const char* name, void* param, unsigned char* buffer, + int32_t numToRead, int32_t* outputCount) { + uintptr_t handleTmp = reinterpret_cast(param); + SIM_JniHandle handle = static_cast(handleTmp); + auto data = callbackHandles->Get(handle); + if (!data) return; + + *outputCount = data->performCallback(name, buffer, numToRead); + }; + + auto id = createCallback(index, callbackFunc, handleAsVoidPtr); + + callbackStore->setCallbackId(id); + + return handle; +} + +void sim::FreeSpiBufferCallback(JNIEnv* env, SIM_JniHandle handle, jint index, + FreeSpiBufferCallbackFunc freeCallback) { + auto callback = callbackHandles->Free(handle); + freeCallback(index, callback->getCallbackId()); + callback->free(env); +} diff --git a/hal/src/main/native/sim/jni/SpiReadAutoReceiveBufferCallbackStore.h b/hal/src/main/native/sim/jni/SpiReadAutoReceiveBufferCallbackStore.h new file mode 100644 index 0000000000..9a98faa51c --- /dev/null +++ b/hal/src/main/native/sim/jni/SpiReadAutoReceiveBufferCallbackStore.h @@ -0,0 +1,46 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#pragma once + +#include +#include + +#include "HAL/Types.h" +#include "HAL/handles/UnlimitedHandleResource.h" +#include "MockData/HAL_Value.h" +#include "MockData/NotifyListener.h" +#include "MockData/SPIData.h" +#include "SimulatorJNI.h" + +namespace sim { +class SpiReadAutoReceiveBufferCallbackStore { + public: + void create(JNIEnv* env, jobject obj); + int32_t performCallback(const char* name, unsigned char* buffer, + int32_t numToRead); + void free(JNIEnv* env); + void setCallbackId(int32_t id) { callbackId = id; } + int32_t getCallbackId() { return callbackId; } + + private: + wpi::java::JGlobal m_call; + int32_t callbackId; +}; + +void InitializeSpiBufferStore(); + +typedef int32_t (*RegisterSpiBufferCallbackFunc)( + int32_t index, HAL_SpiReadAutoReceiveBufferCallback callback, void* param); +typedef void (*FreeSpiBufferCallbackFunc)(int32_t index, int32_t uid); + +SIM_JniHandle AllocateSpiBufferCallback( + JNIEnv* env, jint index, jobject callback, + RegisterSpiBufferCallbackFunc createCallback); +void FreeSpiBufferCallback(JNIEnv* env, SIM_JniHandle handle, jint index, + FreeSpiBufferCallbackFunc freeCallback); +} // namespace sim diff --git a/hal/src/main/native/sim/jni/jnishim.cpp b/hal/src/main/native/sim/jni/jnishim.cpp deleted file mode 100644 index baaf1a235a..0000000000 --- a/hal/src/main/native/sim/jni/jnishim.cpp +++ /dev/null @@ -1,23 +0,0 @@ -// This will be removed when new sim is added in -#include - -static JavaVM* jvm = nullptr; - -namespace sim { -jint SimOnLoad(JavaVM* vm, void* reserved) { - jvm = vm; - - JNIEnv *env; - if (vm->GetEnv(reinterpret_cast(&env), JNI_VERSION_1_6) != JNI_OK) - return JNI_ERR; - - return JNI_VERSION_1_6; -} - -void SimOnUnload(JavaVM * vm, void* reserved) { - JNIEnv *env; - if (vm->GetEnv(reinterpret_cast(&env), JNI_VERSION_1_6) != JNI_OK) - return; - jvm = nullptr; -} -} diff --git a/hal/src/test/java/edu/wpi/first/hal/sim/AccelerometerSimTest.java b/hal/src/test/java/edu/wpi/first/hal/sim/AccelerometerSimTest.java new file mode 100644 index 0000000000..e7e4634d38 --- /dev/null +++ b/hal/src/test/java/edu/wpi/first/hal/sim/AccelerometerSimTest.java @@ -0,0 +1,45 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +package edu.wpi.first.hal.sim; + +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; + +import org.junit.Test; + +import edu.wpi.first.wpilibj.hal.AccelerometerJNI; +import edu.wpi.first.wpilibj.hal.HAL; +import edu.wpi.first.wpilibj.sim.AccelerometerSim; +import edu.wpi.first.wpilibj.sim.CallbackStore; + + +public class AccelerometerSimTest { + static class TriggeredStore { + public boolean wasTriggered = false; + public boolean setValue = true; + } + + @Test + public void testCallbacks() { + HAL.initialize(500, 0); + AccelerometerSim sim = new AccelerometerSim(); + sim.resetData(); + + TriggeredStore store = new TriggeredStore(); + + try (CallbackStore cb = sim.registerActiveCallback((s, v) -> { + store.wasTriggered = true; + store.setValue = v.getBoolean(); + }, false)) { + assertFalse(store.wasTriggered); + AccelerometerJNI.setAccelerometerActive(true); + assertTrue(store.wasTriggered); + assertTrue(store.setValue); + } + } +} diff --git a/hal/src/test/native/cpp/Sim/AccelerometerSimTest.cpp b/hal/src/test/native/cpp/Sim/AccelerometerSimTest.cpp new file mode 100644 index 0000000000..b17e703f54 --- /dev/null +++ b/hal/src/test/native/cpp/Sim/AccelerometerSimTest.cpp @@ -0,0 +1,42 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#include "HAL/Accelerometer.h" +#include "HAL/HAL.h" +#include "Simulation/AccelerometerSim.h" +#include "gtest/gtest.h" + +using namespace frc::sim; + +namespace hal { + +TEST(AcclerometerSimTests, TestActiveCallback) { + HAL_Initialize(500, 0); + + AccelerometerSim sim{0}; + + sim.ResetData(); + + bool wasTriggered = false; + bool lastValue = false; + + auto cb = sim.RegisterActiveCallback( + [&](wpi::StringRef name, const HAL_Value* value) { + wasTriggered = true; + lastValue = value->data.v_boolean; + }, + false); + + EXPECT_FALSE(wasTriggered); + + HAL_SetAccelerometerActive(true); + + EXPECT_TRUE(wasTriggered); + EXPECT_TRUE(lastValue); +} + +} // namespace hal diff --git a/wpilibj/src/main/java/edu/wpi/first/wpilibj/AnalogInput.java b/wpilibj/src/main/java/edu/wpi/first/wpilibj/AnalogInput.java index 593f961759..bd2ba2e9bf 100644 --- a/wpilibj/src/main/java/edu/wpi/first/wpilibj/AnalogInput.java +++ b/wpilibj/src/main/java/edu/wpi/first/wpilibj/AnalogInput.java @@ -9,6 +9,7 @@ package edu.wpi.first.wpilibj; import edu.wpi.first.wpilibj.hal.AnalogJNI; import edu.wpi.first.wpilibj.hal.FRCNetComm.tResourceType; +import edu.wpi.first.wpilibj.sim.AnalogInSim; import edu.wpi.first.wpilibj.hal.HAL; import edu.wpi.first.wpilibj.smartdashboard.SendableBuilder; import edu.wpi.first.wpilibj.util.AllocationException; @@ -350,4 +351,8 @@ public class AnalogInput extends SensorBase implements PIDSource, Sendable { builder.setSmartDashboardType("Analog Input"); builder.addDoubleProperty("Value", this::getAverageVoltage, null); } + + public AnalogInSim getSimObject() { + return new AnalogInSim(m_channel); + } } diff --git a/wpilibj/src/main/java/edu/wpi/first/wpilibj/AnalogOutput.java b/wpilibj/src/main/java/edu/wpi/first/wpilibj/AnalogOutput.java index 32323728d4..258fa34529 100644 --- a/wpilibj/src/main/java/edu/wpi/first/wpilibj/AnalogOutput.java +++ b/wpilibj/src/main/java/edu/wpi/first/wpilibj/AnalogOutput.java @@ -9,6 +9,7 @@ package edu.wpi.first.wpilibj; import edu.wpi.first.wpilibj.hal.AnalogJNI; import edu.wpi.first.wpilibj.hal.FRCNetComm.tResourceType; +import edu.wpi.first.wpilibj.sim.AnalogOutSim; import edu.wpi.first.wpilibj.hal.HAL; import edu.wpi.first.wpilibj.smartdashboard.SendableBuilder; @@ -66,4 +67,8 @@ public class AnalogOutput extends SendableBase implements Sendable { builder.setSmartDashboardType("Analog Output"); builder.addDoubleProperty("Value", this::getVoltage, this::setVoltage); } + + public AnalogOutSim getSimObject() { + return new AnalogOutSim(m_channel); + } } diff --git a/wpilibj/src/main/java/edu/wpi/first/wpilibj/BuiltInAccelerometer.java b/wpilibj/src/main/java/edu/wpi/first/wpilibj/BuiltInAccelerometer.java index ec46b9a1a9..5f6ddfe8d2 100644 --- a/wpilibj/src/main/java/edu/wpi/first/wpilibj/BuiltInAccelerometer.java +++ b/wpilibj/src/main/java/edu/wpi/first/wpilibj/BuiltInAccelerometer.java @@ -11,6 +11,7 @@ import edu.wpi.first.wpilibj.hal.AccelerometerJNI; import edu.wpi.first.wpilibj.hal.FRCNetComm.tResourceType; import edu.wpi.first.wpilibj.hal.HAL; import edu.wpi.first.wpilibj.interfaces.Accelerometer; +import edu.wpi.first.wpilibj.sim.AccelerometerSim; import edu.wpi.first.wpilibj.smartdashboard.SendableBuilder; /** @@ -97,4 +98,8 @@ public class BuiltInAccelerometer extends SensorBase implements Accelerometer, S builder.addDoubleProperty("Y", this::getY, null); builder.addDoubleProperty("Z", this::getZ, null); } + + public AccelerometerSim getSimObject() { + return new AccelerometerSim(); + } } diff --git a/wpilibj/src/test/java/edu/wpi/first/wpilibj/sim/AnalogInputSimTest.java b/wpilibj/src/test/java/edu/wpi/first/wpilibj/sim/AnalogInputSimTest.java new file mode 100644 index 0000000000..ee4a50e13f --- /dev/null +++ b/wpilibj/src/test/java/edu/wpi/first/wpilibj/sim/AnalogInputSimTest.java @@ -0,0 +1,47 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +package edu.wpi.first.wpilibj.sim; + +import static org.junit.Assert.assertEquals; + +import org.junit.Test; + +import edu.wpi.first.wpilibj.AnalogInput; +import edu.wpi.first.wpilibj.hal.HAL; + +public class AnalogInputSimTest { + static class DoubleStore { + public boolean wasTriggered = false; + public boolean wasCorrectType = false; + public double setValue = 0; + } + + @Test + public void testSetCallback() { + HAL.initialize(500, 0); + + + AnalogInput input = new AnalogInput(5); + + AnalogInSim inputSim = input.getSimObject(); + + for (double i = 0; i < 5.0; i+=0.1) { + inputSim.setVoltage(0); + + assertEquals(input.getVoltage(), 0, 0.001); + + inputSim.setVoltage(i); + + assertEquals(input.getVoltage(), i, 0.001); + + } + + + + } +} diff --git a/wpilibj/src/test/java/edu/wpi/first/wpilibj/sim/AnalogOutputSimTest.java b/wpilibj/src/test/java/edu/wpi/first/wpilibj/sim/AnalogOutputSimTest.java new file mode 100644 index 0000000000..08850d4d0b --- /dev/null +++ b/wpilibj/src/test/java/edu/wpi/first/wpilibj/sim/AnalogOutputSimTest.java @@ -0,0 +1,69 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +package edu.wpi.first.wpilibj.sim; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; + +import org.junit.Test; + +import edu.wpi.first.wpilibj.AnalogOutput; +import edu.wpi.first.wpilibj.hal.HAL; + +public class AnalogOutputSimTest { + static class DoubleStore { + public boolean wasTriggered = false; + public boolean wasCorrectType = false; + public double setValue = -1; + + public void reset() { + wasCorrectType = false; + wasTriggered = false; + setValue = -1; + } + } + + @Test + public void testSetCallback() { + HAL.initialize(500, 0); + + + AnalogOutput output = new AnalogOutput(0); + output.setVoltage(0.5); + + AnalogOutSim outputSim = output.getSimObject(); + + DoubleStore store = new DoubleStore(); + + try (CallbackStore cb = outputSim.registerVoltageCallback((s, v) -> { + store.wasTriggered = true; + store.wasCorrectType = true; + store.setValue = v.getDouble(); + }, false)) { + assertFalse(store.wasTriggered); + + for (double i = 0.1; i < 5.0; i+=0.1) { + store.reset(); + + output.setVoltage(0); + + assertTrue(store.wasTriggered); + assertEquals(store.setValue, 0, 0.001); + + store.reset(); + + output.setVoltage(i); + + assertTrue(store.wasTriggered); + assertEquals(store.setValue, i, 0.001); + + } + } + } +}