Robot class cannot be instantiated

My Robot class was initially creating an error when it was instantiated. I cannot find the error anymore, but it was the exact same one previously posted on chief delphi, but there was no solution.

ERROR Unhandled exception instantiating robot org.usfirst.frc.team3205.robot.Robot java.lang.ExceptionInInitializerError at [java.lang.Class.forName0(Native Method), java.lang.Class.forName(Class.java:259), edu.wpi.first.wpilibj.RobotBase.main(RobotBase.java:197)]

My greatest confusion is that the driver station is now outputting nothing at all for this project, but will output for other projects that work.

Here is our Robot class:

package org.usfirst.frc.team3205.robot;

import edu.wpi.first.wpilibj.IterativeRobot;
import edu.wpi.first.wpilibj.command.Command;
import edu.wpi.first.wpilibj.command.CommandGroup;
import edu.wpi.first.wpilibj.command.Scheduler;
import edu.wpi.first.wpilibj.command.Subsystem;
import edu.wpi.first.wpilibj.livewindow.LiveWindow;

import org.usfirst.frc.team3205.robot.commands.autoDrawbridgeGroup;
import org.usfirst.frc.team3205.robot.commands.autoDriveOver;
import org.usfirst.frc.team3205.robot.commands.autoPortcullisGroup;
import org.usfirst.frc.team3205.robot.commands.autoSallyPort;
import org.usfirst.frc.team3205.robot.commands.drive;
import org.usfirst.frc.team3205.robot.commands.drawbridgeGroup;
import org.usfirst.frc.team3205.robot.subsystems.Arm;
import org.usfirst.frc.team3205.robot.subsystems.Drawbridge;
import org.usfirst.frc.team3205.robot.subsystems.DriveTrain;
import org.usfirst.frc.team3205.robot.subsystems.Shooter;
import org.usfirst.frc.team3205.robot.subsystems.Vision;

import edu.wpi.first.wpilibj.smartdashboard.SendableChooser;
import edu.wpi.first.wpilibj.smartdashboard.SmartDashboard;

/**

  • The VM is configured to automatically run this class, and to call the

  • functions corresponding to each mode, as described in the IterativeRobot

  • documentation. If you change the name of this class or the package after

  • creating this project, you must also update the manifest file in the resource

  • directory.
    */
    public class Robot extends IterativeRobot {

    //public static int autoMode;
    public static DriveTrain drivetrain;
    public static Shooter shootey;
    public static Arm arm;
    public static Vision vision;
    public static Drawbridge drawbridge;

    public static OI oi;
    Command autonomousCommand;
    SendableChooser chooser;

    /**

    • This function is run when the robot is first started up and should be
    • used for any initialization code.
      */
      public void robotInit() {
      drivetrain = new DriveTrain();
      shootey = new Shooter();
      arm = new Arm();
      vision = new Vision();
      drawbridge = new Drawbridge();
      oi = new OI();
      chooser = new SendableChooser();
      chooser.addObject(“Auto Drawbridge”, new autoDrawbridgeGroup());
      chooser.addObject(“Auto Portcullis”, new autoPortcullisGroup());
      chooser.addObject(“Auto Sally Port”, new autoSallyPort());
      chooser.addObject(“Drive”, new autoDriveOver());
      SmartDashboard.putData(“Auto mode”, chooser);
      updateSmartDashboard();
      }

    /**

    • This function is called once each time the robot enters Disabled mode.
    • You can use it to reset any subsystem information you want to clear when
    • the robot is disabled.
      */
      public void disabledInit(){

    }

    public void disabledPeriodic() {
    Scheduler.getInstance().run();
    }

    /**

    • This autonomous (along with the chooser code above) shows how to select between different autonomous modes

    • using the dashboard. The sendable chooser code works with the Java SmartDashboard. If you prefer the LabVIEW

    • Dashboard, remove all of the chooser code and uncomment the getString code to get the auto name from the text box

    • below the Gyro

    • You can add additional auto modes by adding additional commands to the chooser code above (like the commented example)

    • or additional comparisons to the switch structure below with additional strings & commands.
      */
      public void autonomousInit() {
      autonomousCommand = (Command) chooser.getSelected();

      /* String autoSelected = SmartDashboard.getString(“Auto Selector”, “Default”);
      switch(autoSelected) {
      case “My Auto”:
      autonomousCommand = new MyAutoCommand();
      break;
      case “Default Auto”:
      default:
      autonomousCommand = new ExampleCommand();
      break;
      } */

      // schedule the autonomous command (example)
      if (autonomousCommand != null) autonomousCommand.start();
      }

    /**

    • This function is called periodically during autonomous
      */
      public void autonomousPeriodic() {
      Scheduler.getInstance().run();
      }

    public void teleopInit() {
    // This makes sure that the autonomous stops running when
    // teleop starts running. If you want the autonomous to
    // continue until interrupted by another command, remove
    // this line or comment it out.
    updateSmartDashboard();
    if (autonomousCommand != null) autonomousCommand.cancel();
    }

    /**

    • This function is called periodically during operator control
      */
      public void teleopPeriodic() {
      Scheduler.getInstance().run();
      updateSmartDashboard();
      }

    /**

    • This function is called periodically during test mode
      */
      public void testPeriodic() {
      LiveWindow.run();
      }

    public void updateSmartDashboard(){
    shootey.updateDashboard();
    arm.updateSmartDashboard();
    drivetrain.updateSmartDashboard();
    }

}

Is that the full exception? The exception you posted is saying that the Robot class threw an exception while being created, so the real issue should be in the second half of the exception.

Now when I attempt to deploy the project I am getting no outputs on the driver station. I tried deploying an example wpi program, which works, but I still get the same error. This is all the driver station gives me:

ERROR: Could not instantiate robot org.usfirst.frc.team3205.robot.Robot!
ERROR: Could not instantiate robot org.usfirst.frc.team3205.robot.Robot!
ERROR Unhandled exception instantiating robot org.usfirst.frc.team3205.robot.Robot java.lang.ExceptionInInitializerError at [java.lang.Class.forName0(Native Method), java.lang.Class.forName(Class.java:259), edu.wpi.first.wpilibj.RobotBase.main(RobotBase.java:204)]
WARNING: Robots don’t quit!

An ExceptionInitializerError is thrown when a static variable cannot be initialized by the JVM. I’m not sure why you are not getting the full stack trace, but the root cause is most likely a bad static initialization somewhere. If I remember my static references correctly, this does not have to be in your robot class itself, since all your subsystems are static variables in your robot class, and the static variables in those classes will be loaded when your Robot class is. My suggestion, if a simple inspection does not work, is to comment out your various subsystems and try to figure out which one is causing issues.

I narrowed down the subsystem, but I don’t understand what the issue could be within it:

package org.usfirst.frc.team3205.robot.subsystems;

import org.usfirst.frc.team3205.robot.RobotMap;
import org.usfirst.frc.team3205.robot.commands.armStart;

import edu.wpi.first.wpilibj.DigitalInput;
import edu.wpi.first.wpilibj.Encoder;
import edu.wpi.first.wpilibj.SpeedController;
import edu.wpi.first.wpilibj.Talon;
import edu.wpi.first.wpilibj.command.Subsystem;
import edu.wpi.first.wpilibj.smartdashboard.SmartDashboard;

/**
*
*/
public class Arm extends Subsystem {

// Put methods for controlling this subsystem
// here. Call these from Commands.
private DigitalInput armUpperLimit;
private DigitalInput armLowerLimit;
private SpeedController armMover;
private Encoder armEncoder;

public Arm(){
	armUpperLimit = new DigitalInput(RobotMap.ARM_UPPER_LIMIT);
	//armMiddleLimit = new DigitalInput(RobotMap.ARM_MIDDLE_LIMIT);
	armLowerLimit = new DigitalInput(RobotMap.ARM_LOWER_LIMIT);
	armMover = new Talon(RobotMap.ARM_MOTOR);
	armEncoder = new Encoder(0,0, false, Encoder.EncodingType.k4X);	//CHANGE THE ENCODER PORTS
}

public void initDefaultCommand() {
    // Set the default command for a subsystem here.
    //setDefaultCommand(new MySpecialCommand());
	setDefaultCommand(new armStart());
}

public boolean isUpperLimitSet(){
	return armUpperLimit.get();
}

// public boolean isMiddleLimitSet(){
// return armMiddleLimit.get();
// }

public boolean isLowerLimitSet(){
	return armLowerLimit.get();
}

public void moveUp(){
	armMover.set(RobotMap.ARM_SPEED);
}

public void moveDown(){
	armMover.set(-RobotMap.ARM_SPEED);
}

public void stopMoving(){
	armMover.set(0.0);
}

public void resetEncoder(){
	armEncoder.reset();
}

public int getEncoder(){
	return armEncoder.getRaw();
}

public void updateSmartDashboard(){
	SmartDashboard.putNumber("Arm Encoder", getEncoder());
	SmartDashboard.putBoolean("Arm Upper Limit", isUpperLimitSet());
	//SmartDashboard.putBoolean("Arm Middle Limit", isMiddleLimitSet());
	SmartDashboard.putBoolean("Arm Lower Limit", isLowerLimitSet());
	SmartDashboard.putNumber("Distance", armEncoder.getDistance()); 
	
}

}

This is a problem, and probably what is causing your crash. You can’t assign a port more then once, your encoder is using port 0 twice (and it might be conflicting with other things in your code as well.

I changed the encoder ports to different values, but I am still getting the error. If I completely comment out the encoder it seems to work fine though.

You still might be reusing ports already in use elsewhere. Make sure that all your ports are unique across your entire program.

Try temporarily commenting out the setDefaultCommand(new armStart()) invocation and see if that clears up the error:


public void initDefaultCommand() {
  // Set the default command for a subsystem here.
  //setDefaultCommand(new MySpecialCommand());
  //setDefaultCommand(new armStart());
}

I think we ran into a similar issue at one point that was triggered by the order in which our commands and subsystems were being constructed.

We worked around the problem by providing an alternative version to our command’s constructor which would accept the subsystem it would work with as a parameter. This would be something like:


public void initDefaultCommand() {
  // Pass reference to this subsystem to command constructor so that
  // we don't get into a race condition when the subsystem is first constructed
  setDefaultCommand(new armStart(this));
}

You will need to update or add a new constructor to your armStart command.

Not sure if this is the same issue you are hitting, but its an easy thing to test.