There are 3 sides to the diff; for every side you can see torques that
are pushing one direction, and torques that are pushing the other
direction. For example, the wheels are driven by the engine, but the
road reaction forces counter their rotations.
The input side of the diff (in a single-diff car) is the engine torque
times the gearbox ratio.
An open diff splits the incoming torque as T_left=T_right=T_input/2.
(where T_input is thus your T_engine*gearBoxRatio). Also, the road
reactions at the wheels are part of the system:
T_input=T_engine*gearBoxRatio
T_left=T_input/2+T_roadreaction_left
T_right=T_input/2+T_roadreaction_right
Then proceed to the quote section below. :)
Note that I think most of us use a tree structure to represent the
driveline. With the clutch, perhaps multiple diffs, and the
accompanying ratios involved, its easier to have a tree object that
can calculate its inertia. For example, I have a RDriveLine class
which can do stuff like CalcInertiaOfChildren(); each component has a
ratio and inertia, and you iterate through the tree, using the SQUARED
ratios to add up inertia values.
I use a piece of code from Gregor Veble which focuses at the diff, and
from the T_input, T_left, T_right numbers is calculates the
accelerations at each point, given the inertia numbers on each of the
3 ends. It's a closed system, which is why I have trouble expanding
that to 3 diffs.
The trick there is to see it as a symmetric acceleration combined with
an asymmetric acceleration (which accelerates the 2 outputs or wheels
away from eachother). Stefano seems to take another approach and
calculates the torques that are transferred from one side to another;
probably much better (read: simpler) in a multiple diff algorithm.
Note that the road reaction forces here are implicitly passed on the
engine because you calculate the accelerations of each end. The
'input' or 'engine' end doesn't accelerate as fast since the total
torque for the entire system gets reduced by the road reaction forces.
You might make this a separate process (engine forward, road reaction
backward) but I'm not sure if you can do this, because of the
differential action inbetween. A Lego differential really helps (there
are 3 in their Tecnic 4x4 Offroad something car) to see how a diff
works. Don't forget that there is a cage that can rotate too.
Indeed, diffs are a pain, esp. if you want 3. :)
Here's what Stefano Casillo (netKar) wrote once:
---
I've tried to write a post here explaining my solution..but it was
really really messy... anyway.. I try again..
U have this situation:
E
|
_______
| |
w1 w2
E, w1 and w2 are torques from engine and the 2 wheels (from the road
reaction).
Now, E is always splitted in 2. equally.. if u see a diff it's easy to
convince yourself.. the engine can just act on the cage of the diff.
Now.. w1 and w2. You need to wait to have them both to actually decide
what to do. The "combined force" of w1 and w2 act on the cage.
Combined force for me is the fraction of the torques acting in the
same direction.
Example.. if w1=100 and w2=30.. the combined force is 30*2.. the 30
N/m of w1 is acting in the same direction of the 30 of w2. so they
combine and go to the cage..
Then u have the unbalanced torque.. the torque difference between w1
and w2.. this won't act on the cage but will be transfered to the
weaker wheel.. in our example we'll have 100-30=70N/m going from w1 to
w2...
This looks crazy I know.. let's do the "wheel on ice" example.. the
engine is sending say 200N/m of torque. .I split 50% and send it to
the wheels.. they accellerate and get the reaction from the road.. the
wheel on tarmac (say w1) will get 100 N/m of reaction force while the
wheel on ice (w2) will get 0N/m reaction...
Step 2.. the combined force is 0 so nothing is going back to the
engine. the unbalanced force is 100 that is sent right to w2 from
w1...
So w1 received 100 from the engine and 100 from the road. so basically
stays there... w2 got 100 from the engine plus 100 from w1 and it's
spinning like a crazy...
It's very easy to get this system and add stuff like internal clutches
to make a limited slip (I just did it yesterday)..
Whatever system u do.. there's one thing u have to check ALWAYS.. the
diff cage speed MUST always be the sum of the wheel speed divided by
2.. always, no matter what kind of diff u have. In a torque based
system like mine.. speed is an output not an input... and u need to
check it always..I've been running with this in my code forever:
if (differential->speed!=(outShaftL->speed+outShaftR->speed)/2.0f)
{
printf("**** DIFF SPEED CHECK FAILED! ****\n");
exit(0);
---
Hope that helps you forward,
Ruud van Gaal
Free car sim: http://www.racer.nl/
Pencil art : http://www.marketgraph.nl/gallery/
