So I’m a new programmer for my team and we program in Java. I already know Java programming language and i get the basics of FRC robotics programming. However our main programmer wants me to be able to make the tank drive and arcade drive methods instead of just knowing how to call them. I’m not allowed to look at the methods FRC provides so I was wondering whats the best way to go about making those methods on my own

Before anyone answers, how much help are you “allowed” to solicit from contributors here on Chief Delphi ? We want to help, but we don’t want to interfere with the assignment you’ve been given.

**

Right, see what you can figure out. Read the sticks and turn on motors indivdually. Start with tank drive.

Start by looking into the Jaguar or Victor classes respective to the speed controllers you have.

A hint, tank drive directly maps joysticks to speed controllers.

Arcade drive is a little trickier, but here’s a hint. To turn the robot you send a positive value to one speed controller and a negative to the other. To go in a direction you send the same value to both controllers. Remember your max value is 1 too, so you may want to consider that if you really want to impress :).

When doing these sorts of problems, I like to make a table. What are my inputs? (Joystick positions). What are my outputs? (Motor PWM values). What are the “points” for which I have well behavior (for example, when your sticks aren’t being touched you probably want to set your motors to 0 speed)?

Once you have this data down in front of you, the relationship between inputs and outputs can be analyzed and you can derive mathematical functions relating them.

im pretty sure you can help me in any way other than actually giving me the code. The reason ive gotta do this is so I can mod the FRC

classes should the need ever arise

We have four motors, would it still be the same for arcade drive and tank drive that way?

Yes, what you will want to do is pair the right speed controllers and left speed controllers together. So anytime you send values to them they should be the same.

L1 left 1 (Jaguar)
R1 right 1
So S1 = speed 1 (variable)
S2 = Speed 2

L1 S1 R1 S2
L2 S1 R2 S2

Tank drive is pretty straightforward. To go straight forward, drive the left and right wheels at the same (forward) speed. To turn right, add a little speed to the left wheel(s), and subtract the same amount from the right wheel(s). To turn left, add a little speed to the right wheel(s), and subtract the same amount from the left wheel(s)

Edit:

The above is actually a generic description for a skid steer vehicle.

For a “tank drive” interface to a skid-steer vehicle (where you are using only the Y axis of each of two joysticks) it is even easier. Just control the left wheel(s) with the left joystick Y-axis, and the right wheel(s) with the right joystick Y-axis.

**

Now the trick is to try to figure out how to make it scale correctly. When you add together 2 values the max # you can see is 2 but the max value you can set is 1. I will let you know though that dividing by 2 is not the answer because then full speed ahead is only a .5 :).

sorry this is in reference to an arcade drive.

are you driving this via joystick or via autonomous?

also you may want to create a drive class that contains 2 functions arcade drive and tank drive.

encapsulating the drive within its own class is good practice.

I am driving via joystick but I dont have the robot or a driver station on my personal laptop to actually test it so thats kind of a problem, and ya my assignment is to pretty much make the drive class with those methods and when I know trig i gotta add mecanum to it, but thats next year.

Actually you can do mecanum without trig. Just like the arcade drive is figuring out how to sum up the motor in the right way based on the joystick input. It certainly isn’t an overly efficient mecanum drive as scaling is an issue, but you can get the idea of it. I think its actually a good problem solving task to do the mecanum without trig :).

Actually doing an encoder based mecanum drive could be done without trig too. Its only when you start going field centric that you really need trig.

Also the trig isn’t too bad either, you could find it online. Just treat the left joystick as a circle and find the angle and distance from center based on the 2 values.

x^2 + y^2 = magnitude^2

angle = arctan(y/x)

soh cah toa
sin = opposite over hypotenuse

cos(angle)*mag = y mag
sin(angle)*mag = x mag

give all 4 motor the y mag

top right back left y mag + x mag
top left back right y mag - x mag
i may have the side flipped not sure

programming a mec via trig is a lot easier than doing it without it, that why i suggest you try doing it by taking all joystick values / 2 and setting the motors via that. its def possible. for scaling reasons i’d leave out rotation at first.

if your feeling really ambitious let a gyro set the rotation value and you just set the x and y.

Lol Ill save mecanum for later on though, so ya i kinda got the logic behind tank, what about arcade?

Rotation is handled as plus or minus

Left is y. - x
Right is y+ x

They may be flipped

Once again remember scaling

FR = -Y - X -Z

FL = -Y +X +Z

RR = -Y +X -Z

RL = -Y -X +Z

How does trig make the above any easier ?

for scaling reasons i’d leave out rotation at first.

Scaling is straightforward. Find the max absolute value of the 4 wheel speed commands above. If that max value exceeds the max command you want to send, then divide all 4 wheelspeeds by it.

**

That doesnt work for moving the joystick to the corners or towards them. thats the hardest part of arcade and ive been trying a bunch of algorithims but none of them can be used for more than one specific coordinate

well you could do an if > 1 output 1
or a divide by 2
those should work somewhat.

the best case would be to use trig even for an arcade drive to ensure max values

Look at this diagram, and see if you can figure out what the left and right motor speeds should be for the red, green, and blue dots. If you can do that, you should be able to design an algorithm to compute the wheel speeds for any joystick position.

Some drivers find this behavior more intuitive.

**

What do you mean by “doesn’t work” and “one specific coordinate” ? Please post a couple of example calculations to illustrate the problem you are encountering.

**

I assume it has something to do with the math being done. If you pass a value >1 or <-1 i’m pretty sure the robot does nothing.

Also knowing whether or not iterative or simple robot are being used is helpful too. I prefer simple robot as I like to have control over initialization and my loops.

My interest has been peaked by approaching the arcade drive similar to a mecanum by using arc functions. however arc estimators will have to be coded up as only standard sin cos and tan are supported