Tag Archive for ISF transmission

Transmission ECU – Brake Sense Circuit

GPI4 (Brake sense)

This circuit is located behind the center of the Ampseal connector. This circuit is built as a digital input, but we must bring the nominal 12V brake light voltage down to the 5V that the processor pin can handle (~6.5 Volts absolute maximum). R33 forms one leg of the voltage divider, and also limits the current through the Zener diode if the voltage is greater than 5.6 Volts.

  1. Install and solder a 15K Ohm, 1/8 Watt resistor {brown-green-orange, 15KEBK-ND} in R33.
  2. Install and solder a 10K Ohm, 1/8 Watt resistor {brown-black-orange, 10KEBK-ND} in R34.
  3. Install and solder a 5.6 Volt Zener diode {1N4734ADICT-ND} in place of C20, with the banded end towards heat sink. You will have to space it up off the board by about ½” (12mm) to get the leads to fit.

Thats you done!

Megashift brake sense circuit

12v brake sense circuit

 

 

NOTE:

If the input voltage is 14.5 Volts, the voltage divider will reduce this to 14.5 * 10K/(10K+15K) = 5.8 Volts, and the Zener diode further bleeds this off to 5.6 Volts (nominal) with a current of 14.5/15×103 = 0.97 milliamps (the Zener is rated for 1 Watt, which is much higher than we need which is ~1 milliamp * 0.2 Volts = 0.0002 Watts).

If the input voltage is 11.5 Volts, the voltage divider reduce this to 115 * 10/(10+15) = 4.6 Volts, and the Zener diode does nothing. 4.6 Volts is till plenty to trigger the input pin (the acceptable voltage range for ‘high’ on a HCS12 input pin is 3.25 Volts or higher), which means the supply voltage from the brake signal could drop as low as 8.1 Volts and still trigger the input successfully.

 

Transmission ECU – Temperature Circuit

Our next Circuit to build is the Trans fluid temp Circuit.

It is built as a voltage divider (resistance sensing) circuit as we are using Resistance as our input.

This circuit location is called GPI3 and is located near the center of the PCB

  1. Install and solder a resistor, ¼ Watt, 2.49K Ohms {red-yellow-white-brown-brown (on blue), 2.49KXBK-ND} in R23. Space it off the board by about ¼” (6mm). 
  2. Install and solder a 1.0K Ohm, 1/8 Watt resistor {brown-black-red, 1.0KEBK-ND} in R32
  3. Install and solder a 1.0µF, 50V capacitor {399-4389-ND} in C18. You may have to straighten the leads somewhat to get them to fit the holes in the board. Do not let C18 touch R23 once assembled, bend it out of the way as necessary.
  4. Install and solder a 0.001µF, 100V capacitor {399-4202-ND in C19. Do not let in touch R23.

And thats bascially it

Transmission ECU – More circuits (General purpose, PWM, heavy outputs)

The next step is our base circuits for the board. We have 4 General Purpose outputs, GPO1 – GP04 located to centre of the board. The Circuits GPO1 – GPO4 are made up from 1.0K Ohm, 1/8 Watt) in R13, R15, R17, R19 and 4 NPN in Q9, Q10, Q11, Q12

 

 

next we have our VB1, VB2, VB3, VB4 out put circuits. We begin by adding links to R5, R6, R7, R8. We are using 1.0K Ohm, 1/8 Watt resistors instad of wire links as we may want to scope these outputs at a later date.

Next we install and solder 30V Zener diodes {1N4751ADICT-ND} in D11, D12, D13, D14

To Complete the VB Circuits we install the Heatsink. we then Install and solder four large TO-220 size NPN transistors {RFP30N06LE-ND} in Q5, Q6, Q7, Q8 and insulators (under Q5, Q6, Q7, Q8){4724K-ND}) on the heat sink in positions. A liberal amount of heat sink grease is used :)

 

Next we have our PWM1, PWM2, PWM3, PWM4 Circuits. First we solder in our main jumpers in R1, R2, R3, and R4. In R9, R10, and R12 we use 1K ohm resistors and a wire jumper in r11

 

Install and solder 30V Zener Diodes {1N4751ADICT-ND}, D8, D9, D10. We then Install heatsink and solder 3 large TO-220 size NPN transistors {RFP30N06LE-ND} in Q1, Q2, Q4

We finish off the PWM circuits by installing and heatsinking a RFP30N06LE-ND into Q3

 

 

 

design and build..The AA80E Transmission test Bench

Well in Order to Fully test and debug the AA80E Controller, AA80E transmission, and also control functions (paddle shift etc etc) we are building a Transmission test Rig. We started today on the Bare bones of the Frame Work.

 

And the plan..

We will be using a 3HP 2800 3 Phase motor which will be motor than plenty to spin the aa80e with no actually load…ie. the rear diff and wheels and car weight.

The 3phase motor will be controlled using a single phase to 3 phase digital inverter unit. This will give us full control of the motor speed and braking. In theory at 200hz we should see around 5000rpm at the motor, though 3500rpm is all we need for most testing.

Transcooler will be mounted on the test rig, and from the bench we will have our paddle controllers, selector mechanism, load and tps STIMulator and PC to monitor and edit Data (Megashift) from the Trans controller.

This will save a lot of development time and help iron out problems a lot faster than trying to do whilst in car.

so the basic idea is..

components should start arriving this week ;)

 

Marty

CAN DASH DISPLAY – For custom AA80E controller

In Order to display Vital information from the AA80E controller we will be designing a Custom TFT Cluster either replacing Stock Speedo or part of the Stock Speedo. We will probably use an Arm developement Board and access the controller data directly Via CAN.

or small OLed display system :-

 

To poll the needed data From the MSGPIO will we use a read command to read data from the OUTPC table. The outpc offset values (and the descriptions used by TS) are all listed in the section below starting with: [OutputChannels]

The variables are described in lines like this:

seconds = scalar, U16, 0, “sec”, 1.000, 0.0

The first label is the parameter name the tuning software uses (it can be almost anything), the second value tells the tuning software if it should handle the value as individual bits, or as a number.

The next value tells us the format of the number, U16 denotes an unsigned 16 bit number (and ‘int’) , S08 denotes a signed 8 bit number (a ‘char’), and so on.

The value after the number type is the offset, in bytes, of the parameter from the start of the structure. the first value (“seconds”) has an offset of zero (i.e. it is right at the start of outpc.). The next value (“speedo”) will have an offset of 2, since seconds is two bytes long, and has an offset of zero. The third value (“odometer”) will have an offset of 4, because speedo is two bytes long, and starts at byte 2. The rest are similar.

The next label, “sec”, is the label used in the tuning software for this value.

The next two values are the multiplier and translator for the raw value returned. The first value is multiplied by the multiplier. The second value is added to the raw value. For example:

speedo = scalar, U16, 2, “mph”, 0.100, 0.0

means take the speedo value returned from the GPIO and multiply it by 0.100 (i.e. divide by 10) but don’t add anything (0.0). This is done because the microprocessor cannot handle fraction numbers, so all the internal calculations returns a value time ten, and the conversion is left up to the tuning software.

 

Notes :-

1. the GPIO does not broadcast CAN traffic, so we can not use a device to intercept CAN information.

2. We must send a message via CAN to the GPIO to Request information. The information we are interested in is held in the OUTPC page of memory, This is the GPIO’s realtime data

x72 x01 x07 x00 x38 x00 x08

The above request is

'r',  can_id=1, table=7 (outpc), offset 38h (56 decimal), send 8 bytes 

= sp2PWM

 


3. The realime data is stored in the following Formatt :-
[OutputChannels]

   deadValue        = { 0 } ; Convenient unchanging value.

   ochBlockSize     = 58

 #if CAN_COMMANDS
;full version that works anywhere
   ochGetCommand    = “r\x01\x07%2o%2c”
#else
   ochGetCommand    = “a\x00\x06″
#endif

  seconds           = scalar, U16,    0,     “sec”,      1.000, 0.0
#if NOT_METRIC
  speedo            = scalar, U16,    2,     “mph”,      0.100, 0.0
  odometer          = scalar, U32,    4,   “miles”,      0.001, 0.0
#else
  speedo            = scalar, U16,    2,     “kph”,      0.100, 0.0
  odometer          = scalar, U32,    4,      “km”,      0.001, 0.0
#endif
  auto_mode         = scalar, U08,    8,       ” “,      1.000, 0.0
  downbutton        = bits,   U08,    9 [0:0]
  upbutton          = bits,   U08,    9 [1:1]
  downshift_request = bits,   U08,    9 [2:2]
  upshift_request   = bits,   U08,    9 [3:3]
  error             = scalar, U08,   10,       ” “,      1.000, 0.0
;  serialComm         = bits, U08,     10, [0:0]
;  CAN error          = bits, U08,     10, [1:1]
;  revshiftblock      = bits, U08,     10, [2:2]
;  CVSSreset          = bits, U08,     10, [3:3]
;  VSSerr             = bits, U08,     10, [4:4]
;  gearRangeErr       = bits, U08,     10, [5:5]
;  lowVolts           = bits, U08,     10, [6:6]
;  noBrake            = bits, U08,     10, [7:7]        
  manual_gear       = scalar, S08,   11,       ” “,      1.000, 0.0
  current_gear      = scalar, S08,   12,       ” “,      1.000, 0.0
  target_gear       = scalar, S08,   13,       ” “,      1.000, 0.0
  engine_rpm        = scalar, U16,   14,     “rpm”,      1.000, 0.0
#if LOAD_KPA
  LOAD              = scalar, S16,   16,     “kpa”,      0.100, 0.0
#else
  LOAD              = scalar, S16,   16,       “%”,      0.100, 0.0
#endif  
  #if NOT_METRIC
  clt               = scalar, S16,   18,    “degF”,      0.100, 0.0
#else
  clt               = scalar, S16,   18,    “degC”,      0.100, 0.0
#endif
  linepressure      = scalar, U16,   20,     “psi”,      1.000, 0.0
  lock_TCC          = scalar, U08,   22,       ” “,      1.000, 0.0
  brake             = bits,   U08,   23  [0:0]
  burnstatus        = bits,   U08,   23  [1:1]
  FWD               = bits,   U08,   23  [2:2]
  forceUP            = bits,   U08,   23  [3:3]
  forceDWN            = bits,   U08,   23  [4:4]
#if LOAD_KPA
  LOAD_short        = scalar, U16,   24,     “kpa”,      0.100, 0.0
#else
  LOAD_short        = scalar, U16,   24,       “%”,      0.100, 0.0
#endif
  aux_volts         = scalar, U16,   26,       “V”,      0.001, 0.0
  PC_duty           = scalar, U08,   28,     “pct”,      1.000, 0.0
  converter_slip    = scalar, U08,   29,     “pct”,      1.000, 0.0
  dbug              = scalar, U16,   30,       ” “,      1.000, 0.0
  In1adc            = scalar, U16,   32,   “volts”,      0.00488, 0.0
  In2adc            = scalar, U16,   34,   “volts”,      0.00488, 0.0
  In3adc            = scalar, U16,   36,   “volts”,      0.00488, 0.0  
  solst             = scalar, U08,   38,       ” “,      1.000, 0.0
  Output1           = bits,   U08,   38  [0:0]
  Output2           = bits,   U08,   38  [1:1]
  Output3           = bits,   U08,   38  [2:2]
  Output4           = bits,   U08,   38  [3:3]    
  Output5           = bits,   U08,   38  [4:4]
  Output6           = bits,   U08,   38  [5:5]
  Output7           = bits,   U08,   38  [6:6]   
  chcksum           = scalar, U08,   39,       ” “,      1.000, 0.0
  mileage           = scalar, U16,   40,     “mpg”,      0.010, 0.0       
  FuelAdj           = scalar, S16,   42,       “%”,      0.100, 0.0
  SpkAdj            = scalar, S16,   44,       “°”,      0.100, 0.0
  IdleAdj           = scalar, S16,   46,       ” “,      1.000, 0.0
  SprAdj            = scalar, S16,   48,       ” “,      1.000, 0.0
  In1               = bits,   U08,   50, [0:0]
  In2               = bits,   U08,   50, [1:1]
  In3               = bits,   U08,   50, [2:2]
  In4               = bits,   U08,   50, [3:3]
  sp1PWM            = scalar, U08,   51,      “%”,       1.000, 0.0
  is_rpm            = scalar, U16,   52,    “rpm”,       1.000, 0.0  
  butADC            = scalar, U16,   54,  “volts”,     0.00488, 0.0  
  sp2PWM            = scalar, U08,   56,      “%”,       1.000, 0.0
  TCC_count         = scalar, U08,   57,    “sec”,       0.100, 0.0
  ;     pageSize =  57 + 1 = 58
; total page size must not be a (multiple of 8) plus 1; i.e. 17, 25, … 57, 65, etc.

; Derived Values
   secl             = {(timeNow % 256) – (timeNow % 1)                 }, “sec” ; to keep TS happy despite CAN delays
   second2          = { seconds % 256                                  }, “sec” ; for clock gauge to see resets
   time             = { timeNow                                        }, “sec” ; system time from PC
   kmileage         = { 235.2/mileage                                  }, “l/100km”
#if NOT_METRIC
   os_rpm = { ((speedo*1.467)/((tire_diam/12)*3.1416)) * 60 * axle_ratio }, “”;
#else
   os_rpm = { ((speedo*0.893)/(((tire_diam/2.54)/12)*3.1416)) * 60 * axle_ratio }, “”;
#endif
   VSS_Hz = { (os_rpm * num_teeth)/60  }, “Hz”;
   ic1_period = { 1/VSS_Hz }, “”;
   ic2_period = { 60/(is_rpm * iss_divider ) }, “”;
;   speed2 = { dbug/10 }, “”; Alternate speed for debugging

 

 

Data C Type for the above is :-

 

;   C Type                 Bits              Range                     MegaTune INI Designation
;   ------                 ----              -----                     ------------------------

; - char (=signed char)     8            -128 to 127                S08 (one byte offset each)
; - unsigned char           8               0 to 255                  U08

; ...............................................................................................

; - int  (=signed int)     16          -32768 to 32767             S16 (two byte offset each)
;   (= short)

; - unsigned int           16               0 to 65535                  U16
;   (=unsigned short int)

; ................................................................................................

; - long  (=signed long)   32            -2³¹ to 2³¹ - 1            S32 (four byte offset each)
;   (=long int)     

; - unsigned long          32               0 to 2³² - 1                U32
;   (=unsigned long int)

C types Described here :

http://www.lix.polytechnique.fr/~liberti/public/computing/prog/c/C/CONCEPT/data_types.html

More info from the ms3 CAN implimentation here :-

http://www.msextra.com/doc/ms3/can_tech.html

 

thats all for now! – MARTY

More to follow but here are some vids from testing

 

 

 

 

 

2URGSE + AA80E + ISF DIFF now fitted to the Supra

Well, the supra now has all the major main mehanical work almost complete. The rear end runs with the ISF torsen differential with ISF shafts and Modified outter joints. Custom Prop setup links to the AA80E. Lots of room around the trans tunnel, and with Carefull planning by Colin ment we retained stock trans mounting points, just a few tweaks to be done now to the motor mounts. We have plenty of room to play with for the exhaust manifolds too.

IS-F Torsen LSD Fittment and JZA80 Differences

Today we got the rear end ready for installation. Keypoints :-

 

1. Differental casings are both physically the same, IS-F LSD bolts straight up to the Stock supra rear subframe. Supra inner joints do not fit the IS-F rear differential.

2. lexus Half shafts are correct length and also straight fit for the jza80 rear hubs.

3. IS-F Half shafts will need to be modified on outter joints to have ZA80 ABS rings fitted (1mm from outter flange circumference to be removed) as on the IS-F the abs pickups are built into rear hub bearing. Supra outter joints do not fit the IS-F half shafts due to a different spline pattern.

4. Stock Supra Rear Prop and centre bearing will be used, with the IS-F front prop (2 ins longer than Auto Prop, though AA80E is 2.1ins Shorter than A340E)

 

AA80E 8 speed auto wiring and operational tech info

Again all in PDF format

AA80E-A

AA80E-B

AA80E-C

AA80E-D

AA80E-E

 

The donor Car – 1998 Supra MKIV Jspec n/a

So the lucky car in question is a 1998 mkiv supra, a Jap spec non turbo manual. The car has already been raped of its v161 transmission as most do for a 2jzgte manual conversion. The body is flawless but has been subject to being dressed in a silly frock. So the first steps where to remove the dress, n/a 2jzge engine, and interior. As you can see the car was raped of a few other items in its life including  the Faelift rear lights.

So out came the very low mileage N/A 2jz-ge power plant which will return back to life as a Forged bottom end and an ideal replacement for a 2JZ-GTE block. waste not want not as my folks used to say.

Which in turn leaves room for the new engine..