Java DigitalInput类代码示例

import edu.wpi.first.wpilibj.DigitalInput; //导入依赖的package包/类
@NotNull
List<DigitalInput> getDigitalInputs() {
  if (inputs.size() == 0) {
    telemetryService.stop();
    for (int i = 0; i < 10; i++) {
      if (outputs.contains(i)) {
        inputs.add(null); // outputs can't be inputs
      } else {
        DigitalInput input = new DigitalInput(i);
        inputs.add(input);
        telemetryService.register(new DigitalInputItem(input));
      }
    }
    telemetryService.start();
    logger.info("initialized inputs and restarted TelemetryService");
  }
  return Collections.unmodifiableList(inputs);
}
 

import edu.wpi.first.wpilibj.DigitalInput; //导入依赖的package包/类
public Arm() {
super("arm", kP, kI, kD);

motor = new Talon(RobotMap.ArmMap.PWM_MOTOR);
motor.setInverted(RobotMap.ArmMap.INV_MOTOR);

encoder = new Encoder(RobotMap.ArmMap.DIO_ENCODER_A, RobotMap.ArmMap.DIO_ENCODER_B);
encoder.setDistancePerPulse(RobotMap.ArmMap.DISTANCE_PER_PULSE);
encoder.setReverseDirection(RobotMap.ArmMap.INV_ENCODER);

upperLimit = new DigitalInput(RobotMap.ArmMap.DIO_LIMIT_TOP);
bottomLimit = new DigitalInput(RobotMap.ArmMap.DIO_LIMIT_BOTTOM);

setAbsoluteTolerance(0.05);
getPIDController().setContinuous(false);
   }
 

import edu.wpi.first.wpilibj.DigitalInput; //导入依赖的package包/类
public Harvester() {		
	
	//TODO: sync left/right motors
	tiltRight = new CANTalon(RobotMap.HARVESTER_AIMING_RIGHT);
	tiltLeft = new CANTalon(RobotMap.HARVESTER_AIMING_LEFT);
	
	//tiltLeft.setVoltageRampRate(5); // this might be a good way to solve our ramp rate issue IE smooth out the jerkiness
	//tiltRight.setVoltageRampRate(5); // this might be a good way to solve our ramp rate issue IE smooth out the jerkiness
	
	limitLeft = new DigitalInput(RobotMap.HARVESTER_LEFT_BUMP_BOTTOM);
	limitRight = new DigitalInput(RobotMap.HARVESTER_RIGHT_BUMP_BOTTOM);
	limitLeftTop = new DigitalInput(RobotMap.HARVESTER_LEFT_BUMP_TOP);
	limitRightTop = new DigitalInput(RobotMap.HARVESTER_RIGHT_BUMP_TOP);
	
	leftPot = new ZeroablePotentiometer(RobotMap.LEFT_AIM_POT, 250);
	rightPot = new ZeroablePotentiometer(RobotMap.RIGHT_AIM_POT, 250);
	leftPot.setInverted(true);
}
 

import edu.wpi.first.wpilibj.DigitalInput; //导入依赖的package包/类
ShooterControl(Encoder encoder, SpeedController pullBackSpeedController, double speedControllerMaxRpm,
               DigitalInput limitSwitch, DoubleSolenoid gearControl, Servo latchServo,
               Relay angleControl)
{
    m_latchReleaseServo = latchServo;
    m_currentState = SHOOTER_CONTROL_STATE_WAIT;
    m_encoder = encoder;
    m_pullBackSpeedController = pullBackSpeedController;
    m_angleControl = angleControl;
    m_speedControllerMaxRpm = speedControllerMaxRpm;
    m_limitSwitch = limitSwitch;
    m_pullBackEncoderRpm = new EncoderRPM();
    m_pullBackEncoderRpm.Init(m_pullBackSpeedController, m_encoder, (-1)*m_speedControllerMaxRpm, m_speedControllerMaxRpm, 0.05, 100, m_limitSwitch);
    m_releaseFromMidptEncoderRpm = new EncoderRPM();
    m_releaseFromMidptEncoderRpm.Init(m_pullBackSpeedController, m_encoder,(-1)*m_speedControllerMaxRpm/4,m_speedControllerMaxRpm,0.05, 3);
    m_gearControl = gearControl;
    m_latchReleased = false;
    m_gearReleased = false;
    m_isPulledBack = false;
}
 

import edu.wpi.first.wpilibj.DigitalInput; //导入依赖的package包/类
public Lift(int motorChannel, int brakeChannelForward, int brakeChannelReverse, int encoderChannelA,
		int encoderChannelB, int boundaryLimitChannel, String subsystem) {
	motor = new Talon(motorChannel);
	brake = new DoubleSolenoid(RobotMap.solenoid.Pcm24, brakeChannelForward, brakeChannelReverse);
	encoder = new Encoder(encoderChannelA, encoderChannelB);
	boundaryLimit = new DigitalInput(boundaryLimitChannel);

	LiveWindow.addActuator(subsystem, "Motor", motor);
	LiveWindow.addActuator(subsystem, "Brake", brake);
	LiveWindow.addSensor(subsystem, "Encoder", encoder);
	LiveWindow.addSensor(subsystem, "Boundary Limit Switch", boundaryLimit);

	encoder.setPIDSourceType(PIDSourceType.kRate);
	pid = new PIDSpeedController(encoder, motor, subsystem, "Speed Control");
	subsystemName = subsystem;
}
 

import edu.wpi.first.wpilibj.DigitalInput; //导入依赖的package包/类
/**
 * Constructs a new Launcher, with two Talons for winding, a release relay,
 * and a limit switch for winding regulation based on input from a
 * MaxbotixUltrasonic rangefinder.
 */
public Launcher() {
    super("Launcher");

    winderL = new Talon(RobotMap.WIND_LEFT_PORT);
    winderR = new Talon(RobotMap.WIND_RIGHT_PORT);

    releaseMotor = new Relay(RobotMap.RELAY_PORT);
    
    camera = new AxisCameraM1101();
    rangefinder = new MaxbotixUltrasonic(RobotMap.ULTRASONIC_RANGEFINDER);

    limitSwitch = new DigitalInput(RobotMap.LIMIT_SWITCH);
    counter = new Counter(limitSwitch);

    counterInit(counter);
}
 

import edu.wpi.first.wpilibj.DigitalInput; //导入依赖的package包/类
/**
 * Instantiates the Sensor Input module to read all sensors connected to the roboRIO.
 */
private SensorInput() {	
	limit_left = new DigitalInput(ChiliConstants.left_limit);
	limit_right = new DigitalInput(ChiliConstants.right_limit);
	accel = new BuiltInAccelerometer(Accelerometer.Range.k2G);
	gyro = new Gyro(ChiliConstants.gyro_channel);
	pdp = new PowerDistributionPanel();
	left_encoder = new Encoder(ChiliConstants.left_encoder_channelA, ChiliConstants.left_encoder_channelB, false);
	right_encoder = new Encoder(ChiliConstants.right_encoder_channelA, ChiliConstants.right_encoder_channelB, true);
	gyro_i2c = new GyroITG3200(I2C.Port.kOnboard);
	
	gyro_i2c.initialize();
	gyro_i2c.reset();
	gyro.initGyro();
	
	left_encoder.setDistancePerPulse(ChiliConstants.kDistancePerPulse);
	right_encoder.setDistancePerPulse(ChiliConstants.kDistancePerPulse);
}
 

import edu.wpi.first.wpilibj.DigitalInput; //导入依赖的package包/类
/**
 * A private constructor to prevent multiple instances from being created.
 */
private Winch(){
	winchMotor = new Talon(RobotMap.winchMotor.getInt());
	winchInputSwitch = new DigitalInput(RobotMap.winchLimitSwitch.getInt());
	winchSolenoid = new MomentaryDoubleSolenoid(
			RobotMap.winchExtPort.getInt(),RobotMap.winchRetPort.getInt());
	winchBallSensor = new AnalogChannel(RobotMap.winchBallSensorPort.getInt());
	intakeBallSensor = new AnalogChannel(RobotMap.intakeBallSensorPort.getInt());
	ballPresent = new Debouncer(RobotMap.ballPresentTime.getDouble());
	ballNotPresent = new Debouncer(RobotMap.ballPresentTime.getDouble());
	ballSettled = new Debouncer(RobotMap.ballSettleTime.getDouble());
	ballPresentOnWinch = new Debouncer(RobotMap.ballPresentOnWinchTime.getDouble());
	
	winchPotentiometer =
			new AnalogChannel(RobotMap.potentiometerPort.getInt());
	winchEncoder = new AverageEncoder(
			RobotMap.winchEncoderA.getInt(),
			RobotMap.winchEncoderB.getInt(),
			RobotMap.winchEncoderPulsePerRot,
			RobotMap.winchEncoderDistPerTick,
			RobotMap.winchEncoderReverse,
			RobotMap.winchEncodingType, RobotMap.winchSpeedReturnType,
			RobotMap.winchPosReturnType, RobotMap.winchAvgEncoderVal);
	winchEncoder.start();
}
 

import edu.wpi.first.wpilibj.DigitalInput; //导入依赖的package包/类
public Loader()
{
    Conveyor = new Victor(ReboundRumble.LOADER_CONVEYOR_PWM);
    loaderInSolenoid = new Solenoid(ReboundRumble.LOADER_IN_SOLENOID_CHANNEL);
    loaderOutSolenoid = new Solenoid(ReboundRumble.LOADER_OUT_SOLENOID_CHANNEL);
    loaderUpSolenoid = new Solenoid(ReboundRumble.LOADER_UP_SOLENOID_CHANNEL);
    loaderDownSolenoid = new Solenoid(ReboundRumble.LOADER_DOWN_SOLENOID_CHANNEL);
    loaderIn = new DigitalInput(ReboundRumble.LOAD_IN_GPIO_CHANNEL);
    loaderOut = new DigitalInput(ReboundRumble.LOAD_OUT_GPIO_CHANNEL);
    loaderUp = new DigitalInput(ReboundRumble.LOAD_UP_GPIO_CHANNEL);
    loaderDown = new DigitalInput(ReboundRumble.LOAD_DOWN_GPIO_CHANNEL);
    loaderDownSolenoid.set(false);
    loaderUpSolenoid.set(true);
    loaderOutSolenoid.set(false);
    loaderInSolenoid.set(true);
}
 

import edu.wpi.first.wpilibj.DigitalInput; //导入依赖的package包/类
public Shooter(Vision vision, JoystickControl controller)
{
    this.vision = vision;
    this.controller = controller;

    averageSpeed = new MovingAverage(ENCODER_AVERAGE_SAMPLES);

    feeder = new Relay(FEEDER_RELAY_CHANNEL);
    feeder.setDirection(Relay.Direction.kForward);
    feederSwitch = new DigitalInput(FEEDER_DIGITAL_SIDECAR_SLOT, FEEDER_DIGITAL_CHANNEL);

    encoderInput = new DigitalInput(ENCODER_DIGITAL_SIDECAR_SLOT, ENCODER_DIGITAL_CHANNEL);
    shooterEncoder = new Counter(encoderInput);
    shooterEncoder.setSemiPeriodMode(true);

    shooterMotor = new Motor(SHOOTER_JAGUAR_CHANNEL, SHOOTER_JAGUAR_INVERTED);

    cycleCounts = 0;
    rateCount = 0.0;
    prevTime = 0.0;
    currentSpeed = 0.0;
}
 

import edu.wpi.first.wpilibj.DigitalInput; //导入依赖的package包/类
public static void init() {
    // BEGIN AUTOGENERATED CODE, SOURCE=ROBOTBUILDER ID=CONSTRUCTORS
    leftSideLeftPaddle = new Spark(0);
    LiveWindow.addActuator("LeftSide", "LeftPaddle", (Spark) leftSideLeftPaddle);
    
    leftSideLeftOut = new DigitalInput(0);
    LiveWindow.addSensor("LeftSide", "LeftOut", leftSideLeftOut);
    
    leftSideLeftIn = new DigitalInput(2);
    LiveWindow.addSensor("LeftSide", "LeftIn", leftSideLeftIn);
    
    rightSideRightPaddle = new Spark(1);
    LiveWindow.addActuator("RightSide", "RightPaddle", (Spark) rightSideRightPaddle);
    
    rightSideRightOut = new DigitalInput(1);
    LiveWindow.addSensor("RightSide", "RightOut", rightSideRightOut);
    
    rightSideRightIn = new DigitalInput(3);
    LiveWindow.addSensor("RightSide", "RightIn", rightSideRightIn);
    
    gearGate = new Spark(2);
    LiveWindow.addActuator("Gear", "Gate", (Spark) gearGate);
    
    gearGearIsIn = new DigitalInput(4);
    LiveWindow.addSensor("Gear", "GearIsIn", gearGearIsIn);
    

// END AUTOGENERATED CODE, SOURCE=ROBOTBUILDER ID=CONSTRUCTORS
}
 

import edu.wpi.first.wpilibj.DigitalInput; //导入依赖的package包/类
public FRCPulseCounter(DigitalInput port, boolean pulseLength) {
	counter = new Counter();
	
	if(pulseLength){
		counter.setPulseLengthMode(0.01);
	}else{
		counter.setUpSource(port);
		counter.setUpDownCounterMode();
		counter.setSemiPeriodMode(false);
	}
	
	quadrature = false;
}
 

import edu.wpi.first.wpilibj.DigitalInput; //导入依赖的package包/类
void removeInput(int channel) {
  if (inputs.size() == 0) {
    logger.debug("removeInput: inputs not initialized, returning");
    return;
  }
  DigitalInput input = inputs.get(channel);
  if (input == null) {
    logger.info("input channel {} is already removed", channel);
    return;
  }
  input.free();
  inputs.set(channel, null);
  logger.info("removed input {}", channel);
}
 

import edu.wpi.first.wpilibj.DigitalInput; //导入依赖的package包/类
@Override
public void perform() {
  PrintWriter writer = terminal.writer();
  writer.println(Messages.bold("\nDigital Input States"));
  for (int i = 0; i < 10; i++) {
    writer.print(Messages.bold(String.format("%2d  ", i)));
    DigitalInput input = dioSet.getDigitalInputs().get(i);
    if (input != null) {
      writer.println(input.get() ? "OFF" : Messages.boldGreen(" ON"));
    } else {
      writer.println("OUTPUT");
    }
  }
}
 

import edu.wpi.first.wpilibj.DigitalInput; //导入依赖的package包/类
public Intake() {
motor = new Spark(RobotMap.IntakeMap.PWM_MOTOR);
motor.setInverted(RobotMap.IntakeMap.INV_MOTOR);

limit = new DigitalInput(RobotMap.IntakeMap.DIO_LIMIT);
stop();
   }