Electronic transmission control and adaptive learning

Van 3 comes back two days after a battery replacement at another shop on the road. Its driver says it "bangs into second and third" when cold and sometimes seems to slip for a moment before third gear takes hold. Hal Osei is worried; the vans are only six years old and he does not want to pay for a transmission. Kiran connects the scan tool and finds no trouble codes, normal fluid temperature readings and a transmission that shifts at the right speeds, just not smoothly. Marty asks one question: "Did the other shop disconnect the battery without a memory saver?" They did. "Then I'll bet the transmission computer has forgotten everything it learned about itself," he says.

This lesson explains how an electronically controlled automatic transmission decides when to shift and how it makes each shift, what its sensors and solenoids do, how it learns and adapts to wear, and what to do when that learning is lost or when the maker issues a software update. It also covers how the control system protects the transmission when something goes wrong.

The transmission control module

Every modern automatic transmission is controlled by a computer, the transmission control module, which may be a separate box, part of the engine computer, or, increasingly, a module mounted on or inside the transmission with its solenoids and sensors as one assembly. Its inputs tell it what the driver wants, what the engine is doing and what is happening inside the transmission. Its outputs are solenoids that control the hydraulic pressure to each clutch and brake.

• Speed sensors measure input or turbine shaft speed, output shaft speed and, in many transmissions, one or more intermediate shaft speeds. From them the computer calculates the actual gear ratio, the converter slip and the progress of every shift.
• The transmission range sensor tells it which position the driver has selected, park, reverse, neutral, drive or a manual range, and allows the engine to start only in park or neutral.
• Accelerator pedal position, engine speed and the engine computer's calculated engine torque, shared over the vehicle network, tell it how hard the driver is asking the vehicle to work.
• Fluid temperature, brake switch status, vehicle speed from the wheel speed sensors, and in some vehicles road grade and trailer status refine its decisions.

The solenoids are of two kinds. On-off shift solenoids open or close a passage to move a shift valve. Variable force or pulse-width-modulated pressure control solenoids, sometimes called linear solenoids, produce a hydraulic pressure proportional to the electric current the computer sends them, which lets it control exactly how quickly and how hard each clutch applies and releases. Modern clutch-to-clutch transmissions such as the vans' ten-speed use a pressure control solenoid for each shifting element and the converter clutch.

Deciding when to shift

The basic decision comes from a shift schedule, a table of the vehicle speeds at which to upshift and downshift for each accelerator pedal position. At light throttle the transmission upshifts early to keep the engine slow and economical; at heavy throttle it holds each gear to a higher speed for performance. Downshift lines sit at lower speeds than the corresponding upshift lines. The gap between them, called hysteresis, keeps the transmission from hunting back and forth between two gears when the speed or the pedal hovers near a shift point.

# Shift schedule with hysteresis: 2-3 shift points against pedal position (illustrative)
up_23   = {10: 19, 30: 25, 60: 36, 100: 53}   # pedal % : upshift speed
down_32 = {10: 11, 30: 16, 60: 26, 100: 43}   # pedal % : downshift speed
def gear_after(gear, pedal, speed):
    if gear == 2 and speed >= up_23[pedal]:
        return 3
    if gear == 3 and speed <= down_32[pedal]:
        return 2
    return gear
gear = 2
for pedal, speed in ((30, 22), (30, 26), (30, 24), (60, 29), (60, 25), (10, 15)):
    new = gear_after(gear, pedal, speed)
    change = f" -> shift {gear}-{new}" if new != gear else ""
    print(f"pedal {pedal:3d} %, {speed:3d} mph: in {gear}{change}")
    gear = new

pedal  30 %,  22 mph: in 2
pedal  30 %,  26 mph: in 2 -> shift 2-3
pedal  30 %,  24 mph: in 3
pedal  60 %,  29 mph: in 3
pedal  60 %,  25 mph: in 3 -> shift 3-2
pedal  10 %,  15 mph: in 2

Real transmissions have many schedules, chosen automatically. A cold transmission may delay upshifts and hold the converter clutch off until the fluid warms. A tow or haul mode, which Gord uses with his trailer, holds gears longer, downshifts sooner on grades, and uses the engine and transmission to help brake on long descents, called grade braking. Many vehicles detect a grade or a heavy load by comparing the engine torque with the acceleration it produces and switch schedules on their own. Eco and sport modes shift the lines one way or the other, and a manual mode lets the driver choose the gear within limits that protect the engine.

Making a good shift

A shift in a clutch-to-clutch transmission is a handover. One element, the offgoing clutch, must release while another, the oncoming clutch, applies, and the timing must be exact. The oncoming clutch first has to fill: its piston chamber must fill with fluid and its piston must take up the clearance in the clutch pack before the plates start to grip. Then comes the torque phase, in which torque transfers from the offgoing element to the oncoming one while the ratio has not yet changed, and the inertia phase, in which the engine and input shaft speed change to the new gear's speed. The engine computer helps by briefly reducing engine torque, by retarding the spark or closing the throttle, during the inertia phase so the shift is quick and soft.

If the oncoming clutch is applied too late or too softly while the offgoing one has already released, nothing is holding the input shaft for a moment and the engine speed flares upward, a short slip that the driver feels as a surge followed by a bump. If it is applied too early or too hard while the offgoing clutch is still holding, the two fight, a tie-up, and the driver feels a harsh bang or the vehicle seems to stumble. A good shift on a modern transmission takes perhaps 0.3 to 0.6 seconds, and the computer measures every one through its speed sensors.

# Shift quality from a data log: 2-3 upshift, input speed sampled every 60 ms
gear2, gear3 = 2.985, 2.146          # vans' ratios
def shift_check(samples, output_rpm):
    before = output_rpm * gear2         # input speed expected in second
    after = output_rpm * gear3          # input speed expected in third
    peak = max(samples)
    flare = peak - before
    start = next(i for i, s in enumerate(samples) if abs(s - before) > 25)
    end = next(i for i, s in enumerate(samples) if abs(s - after) < 40)
    return flare, (end - start) * 0.06
logs = {
    "as found, cold": ([2270, 2275, 2280, 2420, 2510, 2390, 2120, 1840, 1650, 1640, 1638], 760),
    "after relearn":  ([2270, 2272, 2268, 2240, 2160, 2050, 1910, 1780, 1690, 1640, 1637], 760),
}
for name, (samples, out_rpm) in logs.items():
    flare, t = shift_check(samples, out_rpm)
    note = "flare: oncoming clutch late" if flare > 80 else "clean"
    print(f"{name:<16} flare {flare:4.0f} rpm, shift time {t:.2f} s -> {note}")

as found, cold   flare  241 rpm, shift time 0.30 s -> flare: oncoming clutch late
after relearn    flare    3 rpm, shift time 0.36 s -> clean

Adaptive learning

No two transmissions are exactly alike, and every transmission changes as it wears: clutch clearances grow, friction material beds in, springs relax and fluid ages. A fixed program would give shifts that were too harsh on one unit and slipped on another. So the computer adapts. After each shift it compares what happened, the fill time, the flare or tie-up, the shift time, with what it wanted, and adjusts the pressure and timing it will use for that shift next time under the same conditions. These learned corrections, called adaptives or adapts, are stored by shift, by temperature and by torque level, in memory that survives switching the ignition off but not, on many vehicles, a loss of battery power or a module replacement.

When adapts are lost, the computer falls back to its base values, which are deliberately set to be firm, because a slightly harsh shift is safer for the clutches than a slipping one. The transmission shifts at the right times but roughly, often with both flare and bump on some shifts, which is exactly van 3's complaint. It will relearn on its own over hundreds of shifts, but makers provide a faster way: an adaptive relearn procedure, either a scan tool routine that cycles the clutches with the vehicle stopped, or a specified drive cycle that repeats each shift at light, steady throttle with the fluid in a certain temperature range. Some transmissions need both, and some newer ones need a scan tool procedure after any repair before they will shift correctly at all.

Kiran looks up the procedure for the vans' ten-speed. It tells her to confirm the fluid level and temperature, reset the adaptive tables with the scan tool, and then drive the van through a sequence of gentle upshifts and coast-down downshifts at a steady pedal position, repeating each one several times, with the fluid between specified temperatures. She does it on the quiet industrial roads near the shop with Marty in the passenger seat watching the scan tool's shift data. After twenty minutes the 2-3 flare has gone from about 240 rpm to almost nothing and the shift time has settled at about 0.36 seconds. She writes the cause on the repair order as loss of adaptive learning after battery disconnection, and Simone adds a note for Hal: any shop that disconnects the battery should use a memory saver or perform the relearn.

Software updates and technical service bulletins

Transmission behavior is now mostly software. When a maker finds that a shift is harsh in certain conditions, or that a clutch wears faster than expected, the fix is often a calibration update, distributed through a technical service bulletin that describes the symptom, the affected vehicles and the procedure. The Lindqvists' minivan, with its nine-speed transaxle, came in last year with a delayed, harsh 2-3 shift at low speed in traffic. There was a bulletin for exactly that: update the transmission computer's software, then perform a quick learn with the scan tool. The update fixed it. Kiran learns to check for bulletins and calibration updates before she diagnoses any shift-quality complaint, because the newest software is often the first repair.

Reprogramming has its own care. The battery must be supported by a stable power supply, not a charger, for the whole process, because a voltage drop in the middle of programming can leave a module that will not start. The scan tool or pass-through device needs a stable connection and the correct calibration for the vehicle's identification number. After programming, the learn procedure the bulletin specifies must be done, and the vehicle road tested.

Protecting the transmission

The computer constantly checks that the transmission is doing what it was told. Its most important check is the ratio: it divides input speed by output speed and compares the result with the ratio of the gear it commanded. If the ratio is wrong for long enough, a clutch is slipping or the wrong element is applied, and it stores a gear ratio error code. It also checks every solenoid circuit for opens and shorts, the speed sensors for plausibility, the range sensor for invalid combinations, and the fluid temperature. When it finds a serious fault, it goes into a failsafe or limp mode: it commands a fixed gear, often a middle gear that can both start the vehicle and drive it at moderate speed, with maximum line pressure, so the driver can reach a shop without damaging the transmission further.

# Ratio monitoring: actual gear from input and output speed, compared with the command
ratios = {1: 4.696, 2: 2.985, 3: 2.146, 4: 1.769, 5: 1.520, 6: 1.275, 7: 1.000, 8: 0.854, 9: 0.689, 10: 0.636}
def check(commanded, input_rpm, output_rpm, tol=0.03):
    actual = input_rpm / output_rpm
    nearest = min(ratios, key=lambda g: abs(ratios[g] - actual))
    error = abs(actual - ratios[commanded]) / ratios[commanded]
    status = "OK" if error <= tol else f"RATIO ERROR (looks like gear {nearest} or slipping)"
    return actual, status
for cmd, i, o in ((3, 2146, 1000), (6, 1960, 1520), (8, 1300, 1525), (8, 1490, 1520)):
    actual, status = check(cmd, i, o)
    print(f"commanded {cmd:2d}: input {i} rpm, output {o} rpm, actual ratio {actual:.3f} -> {status}")

commanded  3: input 2146 rpm, output 1000 rpm, actual ratio 2.146 -> OK
commanded  6: input 1960 rpm, output 1520 rpm, actual ratio 1.289 -> OK
commanded  8: input 1300 rpm, output 1525 rpm, actual ratio 0.852 -> OK
commanded  8: input 1490 rpm, output 1520 rpm, actual ratio 0.980 -> RATIO ERROR (looks like gear 7 or slipping)