TORCS  1.3.9
The Open Racing Car Simulator
transmission.cpp
Go to the documentation of this file.
1 /***************************************************************************
2 
3  file : transmission.cpp
4  created : Sun Mar 19 00:07:19 CET 2000
5  copyright : (C) 2000-2026 by Eric Espie, Bernhard Wymann
6  email : berniw@bluewin.ch
7 
8  ***************************************************************************/
9 
10 /***************************************************************************
11  * *
12  * This program is free software; you can redistribute it and/or modify *
13  * it under the terms of the GNU General Public License as published by *
14  * the Free Software Foundation; either version 2 of the License, or *
15  * (at your option) any later version. *
16  * *
17  ***************************************************************************/
18 
19 #include "sim.h"
20 #include <portability.h>
21 
22 static const char *gearname[MAX_GEARS] = {"r", "n", "1", "2", "3", "4", "5", "6", "7", "8"};
23 
24 void SimTransmissionConfig(tCar *car)
25 {
26  void *hdle = car->params;
27  tCarElt *carElt = car->carElt;
28  //tdble clutchI;
29  tTransmission *trans = &(car->transmission);
30  tClutch *clutch = &(trans->clutch);
31  tDifferential *differential;
32  int i, j;
33  tdble gRatio, fRatio, gEff; //fEff;
34  tdble gearI;
35  const int BUFSIZE = 256;
36  char path[BUFSIZE];
37 
38  //clutchI = GfParmGetNum(hdle, SECT_CLUTCH, PRM_INERTIA, (char*)NULL, 0.12f);
39  const char* transType = GfParmGetStr(hdle, SECT_DRIVETRAIN, PRM_TYPE, VAL_TRANS_RWD);
40  clutch->releaseTime = GfParmGetNum(hdle, SECT_GEARBOX, PRM_SHIFTTIME, (char*)NULL, 0.2f);
41 
42  fRatio = 0;
43  gEff = 0;
44 
45  /* Link between the differentials */
46  for (j = 0; j < 2; j++) {
47  trans->differential[TRANS_FRONT_DIFF].inAxis[j] = &(car->wheel[j].feedBack);
48  trans->differential[TRANS_FRONT_DIFF].outAxis[j] = &(car->wheel[j].in);
49  }
50 
51  for (j = 0; j < 2; j++) {
52  trans->differential[TRANS_REAR_DIFF].inAxis[j] = &(car->wheel[2+j].feedBack);
53  trans->differential[TRANS_REAR_DIFF].outAxis[j] = &(car->wheel[2+j].in);
54  }
55 
56  trans->differential[TRANS_CENTRAL_DIFF].inAxis[0] = &(trans->differential[TRANS_FRONT_DIFF].feedBack);
57  trans->differential[TRANS_CENTRAL_DIFF].outAxis[0] = &(trans->differential[TRANS_FRONT_DIFF].in);
58 
59  trans->differential[TRANS_CENTRAL_DIFF].inAxis[1] = &(trans->differential[TRANS_REAR_DIFF].feedBack);
60  trans->differential[TRANS_CENTRAL_DIFF].outAxis[1] = &(trans->differential[TRANS_REAR_DIFF].in);
61 
62  if (strcmp(VAL_TRANS_RWD, transType) == 0) {
63  SimDifferentialConfig(hdle, SECT_REARDIFFERENTIAL, &(trans->differential[TRANS_REAR_DIFF]));
64  trans->type = TRANS_RWD;
65  fRatio = trans->differential[TRANS_REAR_DIFF].ratio;
66  //fEff = trans->differential[TRANS_REAR_DIFF].efficiency;
67  } else if (strcmp(VAL_TRANS_FWD, transType) == 0) {
68  SimDifferentialConfig(hdle, SECT_FRNTDIFFERENTIAL, &(trans->differential[TRANS_FRONT_DIFF]));
69  trans->type = TRANS_FWD;
70  fRatio = trans->differential[TRANS_FRONT_DIFF].ratio;
71  //fEff = trans->differential[TRANS_FRONT_DIFF].efficiency;
72  } else if (strcmp(VAL_TRANS_4WD, transType) == 0) {
73  SimDifferentialConfig(hdle, SECT_FRNTDIFFERENTIAL, &(trans->differential[TRANS_FRONT_DIFF]));
74  SimDifferentialConfig(hdle, SECT_REARDIFFERENTIAL, &(trans->differential[TRANS_REAR_DIFF]));
75  SimDifferentialConfig(hdle, SECT_CENTRALDIFFERENTIAL, &(trans->differential[TRANS_CENTRAL_DIFF]));
76  trans->type = TRANS_4WD;
77  fRatio = trans->differential[TRANS_CENTRAL_DIFF].ratio;
78  //fEff = trans->differential[TRANS_FRONT_DIFF].efficiency * trans->differential[TRANS_CENTRAL_DIFF].efficiency * trans->differential[TRANS_REAR_DIFF].efficiency;
79  }
80 
81  trans->gearbox.gearMax = 0;
82  for (i = MAX_GEARS - 1; i >= 0; i--) {
83  snprintf(path, BUFSIZE, "%s/%s/%s", SECT_GEARBOX, ARR_GEARS, gearname[i]);
84  gRatio = GfParmGetNum(hdle, path, PRM_RATIO, (char*)NULL, 0.0f);
85  if ((trans->gearbox.gearMax == 0) && (gRatio != 0.0f)) {
86  trans->gearbox.gearMax = i - 1;
87  }
88  if (gRatio == 0.0f) {
89  carElt->priv.gearRatio[i] = trans->overallRatio[i] = 0.0f;
90  trans->freeI[i] = trans->driveI[i] = 0;
91  trans->gearEff[i] = 1.0;
92  continue;
93  }
94  carElt->priv.gearRatio[i] = trans->overallRatio[i] = gRatio * fRatio;
95  gEff = GfParmGetNum(hdle, path, PRM_EFFICIENCY, (char*)NULL, 1.0f);
96  if (gEff > 1.0f) gEff = 1.0f;
97  if (gEff < 0.0f) gEff = 0.0f;
98  gearI = GfParmGetNum(hdle, path, PRM_INERTIA, (char*)NULL, 0.0f);
99  trans->driveI[i] = (car->engine.I + gearI) * (gRatio * gRatio * fRatio * fRatio);
100  trans->freeI[i] = gearI * (gRatio * gRatio * fRatio * fRatio);
101  trans->gearEff[i] = gEff;
102  }
103 
104  if (gRatio == 0) {
105  /* no reverse */
106  trans->gearbox.gearMin = 0;
107  carElt->priv.gearOffset = 0;
108  } else {
109  trans->gearbox.gearMin = -1;
110  carElt->priv.gearOffset = 1;
111  }
112 
113  carElt->priv.gearNb = trans->gearbox.gearMax + 1;
114 
115  /* initial state */
116  clutch->state = CLUTCH_RELEASING;
117  clutch->timeToRelease = 0;
118  trans->gearbox.gear = 0; /* neutral */
119  trans->curI = trans->freeI[1];
120  switch(trans->type) {
121  case TRANS_RWD:
122  differential = &(trans->differential[TRANS_REAR_DIFF]);
123  differential->outAxis[0]->I = trans->curI / 2.0f + differential->inAxis[0]->I / trans->gearEff[trans->gearbox.gear+1];
124  differential->outAxis[1]->I = trans->curI / 2.0f + differential->inAxis[1]->I / trans->gearEff[trans->gearbox.gear+1];
125  differential->outAxis[0]->Tq = 0;
126  differential->outAxis[1]->Tq = 0;
127  break;
128  case TRANS_FWD:
129  differential = &(trans->differential[TRANS_FRONT_DIFF]);
130  differential->outAxis[0]->I = trans->curI / 2.0f + differential->inAxis[0]->I / trans->gearEff[trans->gearbox.gear+1];
131  differential->outAxis[1]->I = trans->curI / 2.0f + differential->inAxis[1]->I / trans->gearEff[trans->gearbox.gear+1];
132  differential->outAxis[0]->Tq = 0;
133  differential->outAxis[1]->Tq = 0;
134  break;
135  case TRANS_4WD:
136  differential = &(trans->differential[TRANS_FRONT_DIFF]);
137  differential->outAxis[0]->I = trans->curI / 4.0f + differential->inAxis[0]->I / trans->gearEff[trans->gearbox.gear+1];
138  differential->outAxis[1]->I = trans->curI / 4.0f + differential->inAxis[1]->I / trans->gearEff[trans->gearbox.gear+1];
139  differential->outAxis[0]->Tq = 0;
140  differential->outAxis[1]->Tq = 0;
141  differential = &(trans->differential[TRANS_REAR_DIFF]);
142  differential->outAxis[0]->I = trans->curI / 4.0f + differential->inAxis[0]->I / trans->gearEff[trans->gearbox.gear+1];
143  differential->outAxis[1]->I = trans->curI / 4.0f + differential->inAxis[1]->I / trans->gearEff[trans->gearbox.gear+1];
144  differential->outAxis[0]->Tq = 0;
145  differential->outAxis[1]->Tq = 0;
146  differential = &(trans->differential[TRANS_CENTRAL_DIFF]);
147  differential->outAxis[0]->I = trans->curI / 2.0f + differential->inAxis[0]->I / trans->gearEff[trans->gearbox.gear+1];
148  differential->outAxis[1]->I = trans->curI / 2.0f + differential->inAxis[1]->I / trans->gearEff[trans->gearbox.gear+1];
149  differential->outAxis[0]->Tq = 0;
150  differential->outAxis[1]->Tq = 0;
151  break;
152  }
153 
154 }
155 
156 
157 static void setupGear(void* hdle, tCar *car, tCarElt *carElt, tTransmission *trans, tdble gRatio, tdble fRatio, int i)
158 {
159  const int BUFSIZE = 256;
160  char path[BUFSIZE];
161 
162  carElt->priv.gearRatio[i] = trans->overallRatio[i] = gRatio * fRatio;
163  snprintf(path, BUFSIZE, "%s/%s/%s", SECT_GEARBOX, ARR_GEARS, gearname[i]);
164 
165  tdble gearI = GfParmGetNum(hdle, path, PRM_INERTIA, (char*)NULL, 0.0f);
166  trans->driveI[i] = (car->engine.I + gearI) * (gRatio * gRatio * fRatio * fRatio);
167  trans->freeI[i] = gearI * (gRatio * gRatio * fRatio * fRatio);
168 }
169 
170 
171 void SimTransmissionReConfig(tCar *car)
172 {
173  void *hdle = car->params;
174  tCarElt *carElt = car->carElt;
175  tTransmission *trans = &(car->transmission);
176  int i;
177  tdble fRatio = 0.0f;
178  const int BUFSIZE = 256;
179  char path[BUFSIZE];
180 
181  if (trans->type == TRANS_RWD) {
182  SimDifferentialReConfig(car, TRANS_REAR_DIFF);
183  fRatio = trans->differential[TRANS_REAR_DIFF].ratio;
184  } else if (trans->type == TRANS_FWD) {
185  SimDifferentialReConfig(car, TRANS_FRONT_DIFF);
186  fRatio = trans->differential[TRANS_FRONT_DIFF].ratio;
187  } else if (trans->type == TRANS_4WD) {
188  SimDifferentialReConfig(car, TRANS_FRONT_DIFF);
189  SimDifferentialReConfig(car, TRANS_REAR_DIFF);
190  SimDifferentialReConfig(car, TRANS_CENTRAL_DIFF);
191  fRatio = trans->differential[TRANS_CENTRAL_DIFF].ratio;
192  }
193 
194  for (i = MAX_GEARS - 1; i - 2 >= 0; i--) {
195  if (trans->overallRatio[i] > 0.0f) {
196  tCarPitSetupValue* v = &car->carElt->pitcmd.setup.gearsratio[i-2];
197  SimAdjustPitCarSetupParam(v);
198  tdble gRatio = v->value;
199  setupGear(hdle, car, carElt, trans, gRatio, fRatio, i);
200  }
201  }
202 
203  // Handle reverse gear
204  if (trans->overallRatio[0] != 0.0f) {
205  snprintf(path, BUFSIZE, "%s/%s/%s", SECT_GEARBOX, ARR_GEARS, gearname[0]);
206  tdble gRatio = GfParmGetNum(hdle, path, PRM_RATIO, (char*)NULL, 0.0f);
207  setupGear(hdle, car, carElt, trans, gRatio, fRatio, 0);
208  }
209 
210  trans->gearbox.gear = 0;
211 }
212 
213 
214 void SimGearboxUpdate(tCar *car)
215 {
216  /* manages gear change */
217  tTransmission *trans = &(car->transmission);
218  tClutch *clutch = &(trans->clutch);
219  tGearbox *gearbox = &(trans->gearbox);
220  tDifferential *differential = NULL;
221 
222  switch(trans->type) {
223  case TRANS_RWD:
224  differential = &(trans->differential[TRANS_REAR_DIFF]);
225  break;
226  case TRANS_FWD:
227  differential = &(trans->differential[TRANS_FRONT_DIFF]);
228  break;
229  case TRANS_4WD:
230  differential = &(trans->differential[TRANS_CENTRAL_DIFF]);
231  break;
232  }
233 
234  trans->curI = trans->driveI[gearbox->gear + 1] * clutch->transferValue + trans->freeI[gearbox->gear + 1] * (1.0f - clutch->transferValue);
235  if (clutch->state == CLUTCH_RELEASING) {
236  clutch->timeToRelease -= SimDeltaTime;
237  if (clutch->timeToRelease <= 0.0f) {
238  clutch->state = CLUTCH_RELEASED;
239  } else {
240  // If user does not engage clutch, we do it automatically.
241  if (clutch->transferValue > 0.99f) {
242  clutch->transferValue = 0.0f;
243  trans->curI = trans->freeI[gearbox->gear + 1];
244  if (car->ctrl->accelCmd > 0.1f) {
245  car->ctrl->accelCmd = 0.1f;
246  }
247  }
248  }
249  } else if ((car->ctrl->gear > gearbox->gear)) {
250  if (car->ctrl->gear <= gearbox->gearMax) {
251  gearbox->gear = car->ctrl->gear;
252  clutch->state = CLUTCH_RELEASING;
253  if (gearbox->gear != 0) {
254  clutch->timeToRelease = clutch->releaseTime;
255  } else {
256  clutch->timeToRelease = 0;
257  }
258  trans->curOverallRatio = trans->overallRatio[gearbox->gear+1];
259  trans->curI = trans->freeI[gearbox->gear+1];
260  differential->in.I = trans->curI + differential->feedBack.I / trans->gearEff[gearbox->gear+1];
261  differential->outAxis[0]->I = trans->curI / 2.0f + differential->inAxis[0]->I / trans->gearEff[gearbox->gear+1];
262  differential->outAxis[1]->I = trans->curI / 2.0f + differential->inAxis[1]->I / trans->gearEff[gearbox->gear+1];
263  if (trans->type == TRANS_4WD) {
264  differential = &(trans->differential[TRANS_FRONT_DIFF]);
265  differential->outAxis[0]->I = trans->curI / 4.0f + differential->inAxis[0]->I / trans->gearEff[gearbox->gear+1];
266  differential->outAxis[1]->I = trans->curI / 4.0f + differential->inAxis[1]->I / trans->gearEff[gearbox->gear+1];
267  differential = &(trans->differential[TRANS_REAR_DIFF]);
268  differential->outAxis[0]->I = trans->curI / 4.0f + differential->inAxis[0]->I / trans->gearEff[gearbox->gear+1];
269  differential->outAxis[1]->I = trans->curI / 4.0f + differential->inAxis[1]->I / trans->gearEff[gearbox->gear+1];
270  }
271  }
272  } else if ((car->ctrl->gear < gearbox->gear)) {
273  if (car->ctrl->gear >= gearbox->gearMin) {
274  gearbox->gear = car->ctrl->gear;
275  clutch->state = CLUTCH_RELEASING;
276  if (gearbox->gear != 0) {
277  clutch->timeToRelease = clutch->releaseTime;
278  } else {
279  clutch->timeToRelease = 0;
280  }
281  trans->curOverallRatio = trans->overallRatio[gearbox->gear+1];
282  trans->curI = trans->freeI[gearbox->gear+1];
283  differential->in.I = trans->curI + differential->feedBack.I / trans->gearEff[gearbox->gear+1];
284  differential->outAxis[0]->I = trans->curI / 2.0f + differential->inAxis[0]->I / trans->gearEff[gearbox->gear+1];
285  differential->outAxis[1]->I = trans->curI / 2.0f + differential->inAxis[1]->I / trans->gearEff[gearbox->gear+1];
286  if (trans->type == TRANS_4WD) {
287  differential = &(trans->differential[TRANS_FRONT_DIFF]);
288  differential->outAxis[0]->I = trans->curI / 4.0f + differential->inAxis[0]->I / trans->gearEff[gearbox->gear+1];
289  differential->outAxis[1]->I = trans->curI / 4.0f + differential->inAxis[1]->I / trans->gearEff[gearbox->gear+1];
290  differential = &(trans->differential[TRANS_REAR_DIFF]);
291  differential->outAxis[0]->I = trans->curI / 4.0f + differential->inAxis[0]->I / trans->gearEff[gearbox->gear+1];
292  differential->outAxis[1]->I = trans->curI / 4.0f + differential->inAxis[1]->I / trans->gearEff[gearbox->gear+1];
293  }
294  }
295  }
296 }
297 
298 void
299 SimTransmissionUpdate(tCar *car)
300 {
301  tTransmission *trans = &(car->transmission);
302  tClutch *clutch = &(trans->clutch);
303  tDifferential *differential, *differential0, *differential1;
304  tdble transfer = MIN(clutch->transferValue * 3.0f, 1.0f);
305 
306  switch(trans->type) {
307  case TRANS_RWD:
308  differential = &(trans->differential[TRANS_REAR_DIFF]);
309  differential->in.Tq = car->engine.Tq * trans->curOverallRatio * transfer;
310  SimDifferentialUpdate(car, differential, 1);
311  SimUpdateFreeWheels(car, 0);
312  break;
313  case TRANS_FWD:
314  differential = &(trans->differential[TRANS_FRONT_DIFF]);
315  differential->in.Tq = car->engine.Tq * trans->curOverallRatio * transfer;
316  SimDifferentialUpdate(car, differential, 1);
317  SimUpdateFreeWheels(car, 1);
318  break;
319  case TRANS_4WD:
320  differential = &(trans->differential[TRANS_CENTRAL_DIFF]);
321  differential0 = &(trans->differential[TRANS_FRONT_DIFF]);
322  differential1 = &(trans->differential[TRANS_REAR_DIFF]);
323 
324  differential->in.Tq = car->engine.Tq * trans->curOverallRatio * transfer;
325  differential->inAxis[0]->spinVel = (differential0->inAxis[0]->spinVel + differential0->inAxis[1]->spinVel) / 2.0f;
326  differential->inAxis[1]->spinVel = (differential1->inAxis[0]->spinVel + differential1->inAxis[1]->spinVel) / 2.0f;
327  differential->inAxis[0]->Tq = (differential0->inAxis[0]->Tq + differential0->inAxis[1]->Tq) / differential->ratio;
328  differential->inAxis[1]->Tq = (differential1->inAxis[0]->Tq + differential1->inAxis[1]->Tq) / differential->ratio;
329  differential->inAxis[0]->brkTq = (differential0->inAxis[0]->brkTq + differential0->inAxis[1]->brkTq) / differential->ratio;
330  differential->inAxis[1]->brkTq = (differential1->inAxis[0]->brkTq + differential1->inAxis[1]->brkTq) / differential->ratio;
331 
332  SimDifferentialUpdate(car, differential, 1);
333 
334  differential = differential0;
335  SimDifferentialUpdate(car, differential, 0);
336 
337  differential = differential1;
338  SimDifferentialUpdate(car, differential, 0);
339  break;
340  }
341 }
tCarCtrl::gear
int gear
[-1,6] for gear selection
Definition: car.h:349
tCar::params
void * params
Definition: carstruct.h:39
VAL_TRANS_FWD
#define VAL_TRANS_FWD
Definition: car.h:632
SimGearboxUpdate
void SimGearboxUpdate(tCar *car)
Definition: transmission.cpp:214
SimTransmissionUpdate
void SimTransmissionUpdate(tCar *car)
Definition: transmission.cpp:299
tWheel::in
tDynAxis in
Definition: wheel.h:80
tCarPitSetup::gearsratio
tCarPitSetupValue gearsratio[MAX_GEARS - 2]
Definition: car.h:417
tPrivCar::gearRatio
tdble gearRatio[MAX_GEARS]
including final drive
Definition: car.h:301
PRM_TYPE
#define PRM_TYPE
Definition: car.h:527
SimDifferentialReConfig
void SimDifferentialReConfig(tCar *car, int index)
Definition: differential.cpp:87
CarElt
Car structure (tCarElt).
Definition: car.h:455
SECT_DRIVETRAIN
#define SECT_DRIVETRAIN
Definition: car.h:502
tPrivCar::gearOffset
int gearOffset
gearRatio[gear + gearOffset] is the ratio for gear
Definition: car.h:303
tEngine::I
tdble I
Definition: engine.h:45
SimAdjustPitCarSetupParam
bool SimAdjustPitCarSetupParam(tCarPitSetupValue *v)
Definition: simu.cpp:491
CarElt::pitcmd
tCarPitCmd pitcmd
private
Definition: car.h:463
tCar
Definition: carstruct.h:35
tCar::ctrl
tCarCtrl * ctrl
Definition: carstruct.h:38
tTransmission::driveI
tdble driveI[MAX_GEARS]
Definition: transmission.h:59
SimDifferentialUpdate
void SimDifferentialUpdate(tCar *car, tDifferential *differential, int first)
Definition: differential.cpp:167
SimDeltaTime
tdble SimDeltaTime
Definition: simu.cpp:35
tClutch::timeToRelease
tdble timeToRelease
Definition: transmission.h:45
tTransmission::differential
tDifferential differential[3]
Definition: transmission.h:68
tTransmission::overallRatio
tdble overallRatio[MAX_GEARS]
Definition: transmission.h:58
tDifferential::outAxis
tDynAxis * outAxis[2]
Definition: differential.h:54
GfParmGetStr
const char * GfParmGetStr(void *parmHandle, const char *path, const char *key, const char *deflt)
Get a string parameter from the parameter set handle.
Definition: params.cpp:2311
VAL_TRANS_RWD
#define VAL_TRANS_RWD
Definition: car.h:631
TRANS_FWD
#define TRANS_FWD
Definition: transmission.h:56
tDynAxis::spinVel
tdble spinVel
Definition: differential.h:25
TRANS_CENTRAL_DIFF
#define TRANS_CENTRAL_DIFF
Definition: transmission.h:67
tDifferential::inAxis
tDynAxis * inAxis[2]
Definition: differential.h:53
tdble
float tdble
Floating point type used in TORCS.
Definition: tgf.h:48
VAL_TRANS_4WD
#define VAL_TRANS_4WD
Definition: car.h:633
tCarPitSetupValue::value
tdble value
Definition: car.h:375
tEngine::Tq
tdble Tq
Definition: engine.h:47
tCar::carElt
tCarElt * carElt
Definition: carstruct.h:40
SECT_FRNTDIFFERENTIAL
#define SECT_FRNTDIFFERENTIAL
Definition: car.h:484
tCarPitCmd::setup
tCarPitSetup setup
Definition: car.h:441
tClutch::transferValue
tdble transferValue
Definition: transmission.h:47
CLUTCH_RELEASING
#define CLUTCH_RELEASING
Definition: transmission.h:41
setupGear
static void setupGear(void *hdle, tCar *car, tCarElt *carElt, tTransmission *trans, tdble gRatio, tdble fRatio, int i)
Definition: transmission.cpp:157
CarElt::priv
tPrivCar priv
private
Definition: car.h:461
PRM_RATIO
#define PRM_RATIO
Definition: car.h:600
SECT_CENTRALDIFFERENTIAL
#define SECT_CENTRALDIFFERENTIAL
Definition: car.h:496
tGearbox::gearMax
int gearMax
Definition: transmission.h:33
SimDifferentialConfig
void SimDifferentialConfig(void *hdle, const char *section, tDifferential *differential)
Definition: differential.cpp:56
tDynAxis::brkTq
tdble brkTq
Definition: differential.h:27
TRANS_FRONT_DIFF
#define TRANS_FRONT_DIFF
Definition: transmission.h:65
SimTransmissionReConfig
void SimTransmissionReConfig(tCar *car)
Definition: transmission.cpp:171
tCarCtrl::accelCmd
tdble accelCmd
Accelerator command [0.0, 1.0].
Definition: car.h:346
GfParmGetNum
tdble GfParmGetNum(void *handle, const char *path, const char *key, const char *unit, tdble deflt)
Get a numerical parameter from the parameter set handle.
Definition: params.cpp:2392
gearname
static const char * gearname[MAX_GEARS]
Definition: transmission.cpp:22
tPrivCar::gearNb
int gearNb
incl reverse and neutral
Definition: car.h:302
SimTransmissionConfig
void SimTransmissionConfig(tCar *car)
Definition: transmission.cpp:24
CLUTCH_RELEASED
#define CLUTCH_RELEASED
Definition: transmission.h:40
tTransmission::gearEff
tdble gearEff[MAX_GEARS]
Definition: transmission.h:61
PRM_SHIFTTIME
#define PRM_SHIFTTIME
Definition: car.h:604
TRANS_RWD
#define TRANS_RWD
Definition: transmission.h:55
tDynAxis::Tq
tdble Tq
Definition: differential.h:26
tTransmission::clutch
tClutch clutch
Definition: transmission.h:53
tCar::transmission
tTransmission transmission
Definition: carstruct.h:51
tTransmission::freeI
tdble freeI[MAX_GEARS]
Definition: transmission.h:60
tCar::wheel
tWheel wheel[4]
Definition: carstruct.h:46
tClutch::releaseTime
tdble releaseTime
Definition: transmission.h:46
tCar::engine
tEngine engine
Definition: carstruct.h:52
TRANS_4WD
#define TRANS_4WD
Definition: transmission.h:57
MIN
Definition: Endpoint.h:36
tClutch::state
int state
Definition: transmission.h:38
SECT_REARDIFFERENTIAL
#define SECT_REARDIFFERENTIAL
Definition: car.h:495
tGearbox::gearMin
int gearMin
Definition: transmission.h:32
SECT_GEARBOX
#define SECT_GEARBOX
Definition: car.h:503
tDifferential::in
tDynAxis in
Definition: differential.h:51
tWheel::feedBack
tDynAxis feedBack
Definition: wheel.h:81
TRANS_REAR_DIFF
#define TRANS_REAR_DIFF
Definition: transmission.h:66
SimUpdateFreeWheels
void SimUpdateFreeWheels(tCar *car, int axlenb)
Definition: wheel.cpp:392
ARR_GEARS
#define ARR_GEARS
Definition: car.h:603
PRM_EFFICIENCY
#define PRM_EFFICIENCY
Definition: car.h:526
PRM_INERTIA
#define PRM_INERTIA
Definition: car.h:525
tDynAxis::I
tdble I
Definition: differential.h:28
tTransmission::gearbox
tGearbox gearbox
Definition: transmission.h:52
tDifferential::feedBack
tDynAxis feedBack
Definition: differential.h:52
MAX_GEARS
#define MAX_GEARS
Definition: car.h:276
tTransmission::curOverallRatio
tdble curOverallRatio
Definition: transmission.h:62