Robot going left during autonomous

[will_1359]

I'm working on line sensing in autonomous. I've inputted the example code and no matter which sensor is activated when autonomous is running, the robot always spins left, going in circles. When the sensors are not activated, the robot does nothing.

Does anyone have any ideas as to why my robot is spinning left?

[mwtidd]

are you using an arcade drive or a tank drive.

do you have example code?

[will_1359]

class LineTracker {

RobotDrive drive; // robot drive base object
DigitalInput left; // digital inputs for line tracking sensors
DigitalInput middle;
DigitalInput right;
DriverStation ds; // driver station object for getting selections
double defaultSteeringGain = 0.65; // the default value for the steering gain

public LineTracker(RobotDrive d) {
// create the robot drive and correct for the wheel direction.
//drive = new RobotDrive(1, 2); because having two of these screws everything up
drive = d;


drive.setInvertedMotor(RobotDrive.MotorType.kRearL eft, false);
//drive.setInvertedMotor(RobotDrive.MotorType.kFront Left, true);
//drive.setInvertedMotor(RobotDrive.MotorType.kFront Right, true);
//we have only rear motors
drive.setInvertedMotor(RobotDrive.MotorType.kRearR ight, false);

// set the MotorSafety expiration timer
drive.setExpiration(15);

// create the digital input objects to read from the sensors
left = new DigitalInput(1);
middle = new DigitalInput(2);
right = new DigitalInput(3);

// get the driver station instance to read the digital I/O pins
ds = DriverStation.getInstance();
}

/**
* This function is called once each time the robot enters autonomous mode.
*/
public void run() {
int binaryValue; // a single binary value of the three line tracking
// sensors
int previousValue = 0; // the binary value from the previous loop
double steeringGain; // the amount of steering correction to apply

// the power profiles for the straight and forked robot path. They are
// different to let the robot drive more slowly as the robot approaches
// the fork on the forked line case.


double forkProfile[] = {0.70, 0.70, 0.55, 0.60, 0.60, 0.50, 0.40, 0.00};
double straightProfile[] = {0.7, 0.7, 0.6, 0.6, 0.35, 0.35, 0.35, 0.0};
double powerProfile[]; // the selected power profile

// set the straightLine and left-right variables depending on chosen path
boolean straightLine = ds.getDigitalIn(1);
powerProfile = (straightLine) ? straightProfile : forkProfile;
double stopTime = (straightLine) ? 2.0 : 4.0; // when the robot should look for end
boolean goLeft = !ds.getDigitalIn(2) && !straightLine;
System.out.println("StraightLine: " + straightLine);
System.out.println("GoingLeft: " + goLeft);


boolean atCross = false; // if robot has arrived at end

// time the path over the line
Timer timer = new Timer();
timer.start();
timer.reset();

//int oldTimeInSeconds = -1;
double time;
double speed, turn;

// loop until robot reaches "T" at end or 8 seconds has past
while ((time = timer.get()) < 8.0 && !atCross) {
int timeInSeconds = (int) time;
// read the sensors
int leftValue = left.get() ? 1 : 0;
int middleValue = middle.get() ? 1 : 0;
int rightValue = right.get() ? 1 : 0;
// compute the single value from the 3 sensors. Notice that the bits
// for the outside sensors are flipped depending on left or right
// fork. Also the sign of the steering direction is different for left/right.
if (goLeft) {
binaryValue = leftValue * 4 + middleValue * 2 + rightValue;
steeringGain = -defaultSteeringGain;
} else {
binaryValue = rightValue * 4 + middleValue * 2 + leftValue;
steeringGain = defaultSteeringGain;
}

// get the default speed and turn rate at this time
speed = powerProfile[timeInSeconds];
turn = 0;

// different cases for different line tracking sensor readings
switch (binaryValue) {
case 1: // on line edge
turn = 0;
break;
case 7: // all sensors on (maybe at cross)
if (time > stopTime) {
atCross = true;
speed = 0;
}
break;
case 0: // all sensors off
if (previousValue == 0 || previousValue == 1) {
turn = steeringGain;
} else {
turn = -steeringGain;
}
break;
default: // all other cases
turn = -steeringGain;
}
// print current status for debugging
if (binaryValue != previousValue) {
System.out.println("Time: " + time + " Sensor: " + binaryValue + " speed: " + speed + " turn: " + turn + " atCross: " + atCross);
}

// set the robot speed and direction
drive.arcadeDrive(speed, turn);

if (binaryValue != 0) {
previousValue = binaryValue;
}
//oldTimeInSeconds = timeInSeconds;

Timer.delay(0.01);
}
// Done with loop - stop the robot. Robot ought to be at the end of the line.
drive.arcadeDrive(0, 0);
}
}

[kinganu123]

You may need to invert your motors
I suggest you write your own code using truth tables

[mwtidd]

what are you seeing for output on speed values?

// get the default speed and turn rate at this time
speed = powerProfile[timeInSeconds];

this is the only code where it is set.
try making it a static rather than an array like this.
start simple. then get more complicated.

I am guessing that it is 0. That would explain your spinning. Either that or your one motor may not be initialized correctly (1,2) may not be the right ports. or it may we wired correctly.

[Robby Unruh]

My team is still having this same problem. We calibrated sensors and tried lineskier's fix, but that didn't do anything either.

Anyone else have any more suggestions?

[mwtidd]

If you are both using line trackers, I'm guessing you're never seeing atcross
so you never leave the line tracker code. It has something to do with the line tracking code. Basically once you are at target, you should never enter the line track loop again. It sounds like you are either reentering it or never leaving it.

If you have a camera you could use it to simple confirm your at target, rather than the cross. This will let you set the distance to target based on your arm or lift. rather than the fixed point the field gives you.

[Robby Unruh]

Never mind, we fixed it with our own code.

DigitalInput left, middle, right;
left = new DigitalInput(1);
middle = new DigitalInput(2);
right = new DigitalInput(3);

public void autonomous() {
    while(isAutonomous()) {
        if(left.get()) {
            // drive code to turn right.
        } else if(middle.get()) {
            // drive code to go straight.
        } else if(right.get()) {
            // drive code to turn left.
        }
    }
}

or something like that. It was pretty simple, now that I think about it.