Archive for Technical details

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

 

 

 

Transmission ECU – Hello world Time

So, the first part of our Transmission ECU build is to install the basic circuitry and hardware for our PC coms so we can Flash the ECU with the megashift Firmware.

 

A. Base circuits:

 

  1. Remove excess PCB material: The board is shipped with surplus PCB material on each edge that is about ¼ inch (6mm) wide. You can leave this material on if you are using a custom enclosure, it might make for easier mounting is some situations. However, in most cases, this material must be removed. You do this by using a pair of pliers to flex the excess material along each edge until is snaps off.
  2. PCB/case: Check the fit of the GPIO printed circuit board in the case. It goes into the next to last slots (nearest the case bottom). Do not put the GPIO PCB into the bottom grove, the bottom of this groove is wide enough that it may short out some circuits.Be sure to start it as close to ‘square’ as possible, otherwise it will bind. The PCB should slide into the case fairly easily, but be held snugly. If the PCB doesn’t fit, or is too tight, you have to narrow the board slightly. you do this with a coarse file. Run it along the heat sink edge of the board 10-20 times, then recheck the fit. Repeat as necessary until the board fits properly in the PCB. Then blow the PCB clean with compressed air.Note that if you wish to mount the GPIO PCB in a non-standard case, three mounting holes are provided:

     

     

  3. Heat sink: Prepare the heat sink. You will make this out of 1/8″ (3mm) aluminum flat strapping, 5/8” wide (15.8 mm) by 3.94 inches (100mm) long. You will drill 8 holes in it to match the PCB heat sink area. 

    Because aluminum isn’t typically sold in 5/8″ widths, you may have to cut down wider aluminum (¾” or 1″) to get a heat sink that will to fit.

    The easiest way to get the hole spacing right is to transfer the holes from the PCB to the aluminum strip by placing them together and using a felt pen to mark the hole locations on the aluminum strip through the PCB.

    Be sure to allow enough room for the aluminum strip to fit in the case, and allow enough room so that it won’t contact the component leads. Make sure the heat sink rests up against the case when installed to get the thermal contact between the case and the heat sink. Sand both sides of the heat sink to ensure there are no burrs.

     

  4. Case End-Plates: Here is a rough drawing for the connector end plate for the EAS-400 enclosure with both the V2.10 GPIO board and MegaSquirt® V3 main board in the same case (because cases and boards may vary, you should check all of these measurements carefully with your own hardware). 

    The end plate material should be 0.080″ to 0.125″ thick. The Ampseal connector is sealed internally in this configuration, but the enclosure itself is not sealed (because of the DB37 as well as the tolerances of the end plate to the outside flange of the Ampseal connector (rather than screwed to the face of the flange).

    The GPIO board fits in the bottom slot of the its half of the case, while the V3 main board sits in the second from the bottom slot of its part of the case. Note that the DB37 and Ampseal connector are very close – there isn’t much material left (~0.070″), and you will have to be careful to avoid damaging this area while machining. Thicker material will make this easier, of course.

     

  5. Install and solder the voltage regulator U1 {LM2937ET-5.0-ND}. This is a TO-220 size component (three pins sticking out of a black case, with a tab and mounting hole on the opposite edge) located in the corner of the board furthest from where the 35 position Ampseal connector will be installed, nearest the heat sink. 

    It has its own location among the SMD components in that corner of the board. You have to bend the leads to a 90° angle so the regulator can site flat against the board, then solder it and screw it the board with a #4-40 nylon bolt and nut (with heat transfer compound (aka. ‘heat sink grease’) between the regulator and board). You do not need a separate heat sink for the voltage regulator (shown in the diagram below), the voltage regulator can be mounted directly to the PCB (with heat sink compound), as long as you are not using the 5Vref supply for powering off-board accessory circuits.

     

  6. CAN termination resistor: You will install this 120 Ohm, 1/4 Watt resistor (R82) if you have two CAN devices in your network (i.e. the GPIO board and MS-II). If you have more than two devices in the network, you only install the resistor in the devices at the ends of the CAN network. If required, install and solder the 120 Ohm, ¼ Watt resistor {brown-red-brown, 120QBK-ND} in R82. This is located in the corner of the PCB furthest from the Ampseal connector and heat sink. Space the CAN termination resistor up off the board by approximately 1/4″ to 1/2″ (6mm to 12mm), and make sure the lead closest the edge will not contact the case when the PCB is installed in the enclosure. If your board is not at the end of the CAN chain, DO NOT jumper this resistor location, leave it empty

     

  7. Ampseal
    1. Connector: The connector should be soldered to the PCB. Be sure it snaps into place in the PCB, then solder each of the 35 pins from the underside of the board. Take your time and be methodical, as missing or poorly soldering one or more pins can cause problems that are very hard to troubleshoot later.
    2. Pigtail: The best instructions for assembling the harness pigtail are Tyco’s own instructions, get the PDF file here: Ammpseal 35 pigtail assembly instructions

  8. Serial Communications:You have a choice here. You can bring the serial communications out a serial jack (with a 2.5mm mini stereo jack, which is convenient) or you can bring the serial communications out the Ampseal connector (which offers the possibility of weather sealing).

     

    1. Ampseal Serial:
      • Rx: Jumper from the via marked “Rx” near the bootloader jumper to the via marked “Rx” near the Ampseal connectors rear edge with 20-24 gauge insulated wire. This will bring Rx out on Ampseal pin 21.
      • Tx: Jumper from the via marked “Tx” near the bootloader jumper to the via marked “Tx” near the Ampseal connectors rear edge with 20-24 gauge insulated wire. This will bring Tx out on Ampseal pin 22.
      • Gnd: Use Ampseal pin 17 as a ground.
      • You can devise your own serial cable, the illustrations below might help.

    2. Bootloader header {A26520-40-ND – cut to suit}: The Boot Header {JP5) on the board near the serial jack is used to reprogram the CPU in your GPIO processor (not the tuning parameters, but the actually code that uses the tuning parameters). Install the 2-position header, but leave it open (do not bridge the pins with a jumper), though you can leave a jumper (S9000-ND) hanging on just one pin as a handy storage location.Depending on what you want from your GPIO controller, though, you may end up using the boot header to eventually to load code. To load new code, you put jumper on the two pins on JP5 with no power applied to the board, and once the jumper is in place apply power to the board and use the downloader program.
    3. Some people have put a momentary switch (normally open – NO) across the boot header, and place the switch so they can go into bootloader mode simply by pressing this switch while powering up, without opening the case. (If you do this, be sure it can’t be pressed accidentally.)

       

    4. BDM (Background Debug Module) header: This 3×2 header is used to load the serial monitor program to the processor (to act as a bootloader for adding new code version), as well as for looking at the state of code running on the processor when developing new code (in conjunction with a BDM cable, etc.). This is located in the corner of the PCB furthest from the Ampseal connector and heat sink, near the CAN termination resistor (R82) you installed earlier. If you wish to install this header, solder it into position. 

       

    5. 25×2 Header {WM8135-ND, S9000-ND}: Before installing the header, you must use insulatedwire (~20-22 gauge) to jumper:
      • AD1 to GPI2 at 25×2 header, and
      • PT7 to VB1 at 25×2 header.

      Do these jumpers first, then cut the 25×2 header with small side cutters to fit remaining holes as necessary. Solder each of the header pins from the bottom side of the board (you can use tape to hold the header in place while it is upside down). For now, do not install jumpers on all the applicable circuits (see the table near the top of this document). You can do that after checking the circuits at the end of the build process.
      You can use snipped off leads as jumpers instead and save several dollars on the WM8135 header and jumpers – if you are doing this, wait until the end of the build to install the remaining jumpers – and save the snipped off leads from other components as you go.
      (You could install the complete 25×2 header then jumper the relevant pins by soldering wires directly to the header pins, if you prefer. Be sure not to bridge adjacent pins, of course.

  9.  
    1. Double check that you have jumpered the correct locations.

      Note that on the V2.00 GPIO boards ONLY, NOT the V2.10 boards, there are errors on the silkscreen labeling at the 25×2 header, this was corrected on V2.10 boards. The actual circuit connections are the same on both boards, they are just labeled correctly on V2.10+ boards. See this link for more information.

      Loading Code on Your GPIO Controller Now that you have assembled the base circuits on your GPIO, you need to load the GPIO code. Completing this step will verify that CPU and serial communications circuits are functioning. To use Eric Falgren’s Windows downloader.exe:

    1. Power down the GPIO Controller,
    2. Put the boot jumper on both pins of the header marked JP5 (for “bootloader”) near the serial plug on the GPIO board,
    3. Power up the GPIO Controller by connecting the power supply ground on one of the Ampseal pins 18, 19, 20 (through the appropriate lead). Then apply 12 volts (nominal, 9V to 15V is okay) to Ampseal pin 1.
      Note: When in bootloader mode, the GPIO may allows a full 12V to flow in some circuits. If your set-up depends on PWM to limit the current in these solenoids, you MUST pull the fuse to these devices before entering bootloader mode to load new code.
    4. Start the Windows downloader program (get it here), and select the appropriate COM port number for your serial connection (if you don’t know your serial COM port, run the portCheck program).
      See this link for downloading using other platforms than Windows..
    5. Select the appropriate .S19 file, and the downloader will read, write and verify the code to the processor in about 10 seconds or so.
    6. The process ends with a message like “Verification succeeded, XXX records total (4 skipped).” (where XXX is a large number that varies from one code version to the next),
    7. Shut down the downloader program,
    8. Remove power from the GPIO Controller,
    9. Remove the boot jumper (or put it on just one pin of the boot header for storage),
    10. Start the tuning software (TunerStudioMS) and set the COM port and speed if necessary.
    11. You will need to download and activate the latest INI file. Under the ‘File/Project/Project Properties’ of TunerStudio, click on the ‘Other’ check box.
    12. Click the ‘Browse’ button.
    13. Navigate to the INI file you downloaded for your code (for example, for MShift™ code you would use the INI from the link www.msgpio.com/manuals/mshift/V2code.html).
    14. Click on the appropriate INI file you downloaded from the code page (www.msgpio.com/manuals/mshift/V2code.html) to activate it.

AA80E intergration document Part 1

aa80e-intergration-pt1

in-Car PC

 

Well with so many various options available for in car PC equipment, we have decided to go down the route of an open source environment with a bit of hacking of a well known system. The system with be accessed via a passive 7 inch capacitative touch-screen and bmw I-drive like main controller. OS will be a flash based affair to speed up start up times. At the moment im an testing various Window and Linux builds to see which have the fastest boot Times. main unit itself takes up a very small footprint of only 180 x 130 x 115mm. Usually applications such as media centre, bluetooth, DAB radio will be run, with sat nav send custom data via serial to the drivers TFT cluster to indicate direction.

Specs are :-

Based on Intel’s Poulsbo/US15W mobile chipset.

CPU: 1.3GHz Intel Z520 Single-Core, Hyper-threaded, Atom CPU

Chipset: Intel US15W (400/533MHz FSB)

Graphics: Intel GMA500 (with hardware acceleration for H.264, MPEG2, MPEG4, VC1, WMV9)
Storage:

Network Features:

 

Power: 5v DC

Screen: 7in Sharp LQ070Y3LG4A 800×480 LCD, 16m colour (24-bit), LED backlit, capacitative touch-screen

Size: 180 x 130 x 115mm

Weight: Approx 650g

Power Usage

1.24A/6.2W during startup

1.09A/5.4W with the clock on screen set at lowest brightness

1.40A/7.0W with the clock on screen set at Highest brightness

0.14A/0.7W in STANDBY set by performing a SYSRQ+O

 

 

So what is it?

The device in question in known as a Joggler. It was built by 02 as a sort of media player/message centre and infotainment unit for the home. Now for the best part, although pretty useless in thier current formatt the have A LOT of potential, especially in the CAR PC World. We purchased ours new for £49.99..yes you read that right!

But some very clever people seen the potential behind the unit. The first thing to do was to find away of bypassing the 02 firmware/software and running our own operating system. More info at http://jogglerwiki.info/

So, how do we go about creating our own system?

Well its actually easy enough. We use a Custom boot loader and an Operating system of our choice. For test purposes we used XP tablet edition. information of bootloader uiling can be found here http://jogglerwiki.info/index.php?title=Efi

Currently we have our Joggler booting and running XP from a 32gb Sandisk USB 2.0 Flash pen in around 1 minute, and running various car PC front ends with ease. The next step now will be to run with a fast USB harddrive to increase boot time.

For details on building the XP image can be found here :-

http://www.jogglerwiki.com/wiki/WindowsXP

 

Now, we used XP as a test image to get to grips with bootloaders and OS images. But, our ultimate goal will be to run the MEEGO platform on the Joggler. MEEGO is slowly becoming an industry standard, with Companies like FORD taking it on for thier in car systems….So why shoulodnt we!                     https://meego.com/about/

Heres a few images of our joggler running XP and riderunner/shotgun front ends.

 

Thats all for now…more to come on GPS, SATNAV, DAB, and gesture control…..

 

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

 

 

 

 

 

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 transmission – controlling

So after extensive research on the net regarding various controllers for the AA80E, we found there wasnt much out there that could support the number of solenoids used in the transmission.

Many Controllers seem to be cuaght in a time warp in that they are based around the usual 4L80E 4L60E 4L85E type transmissions of yesteryear.

We even approached PCS who wouldnt even reply to our questions regarding the TCM2000 controller, which at first look seemed the perfect Candidate.

So the DIY approach was needed. After some research we found that control should be possible by building our own controller. This will be based around the MSGPIO board.

Although a basid I/O board, coupled with the right components this becomes a very powerfull Transmission Controller. The board has been in service as a transmission controller and has provided great results.

The board is Flashed with MegaShift™ automatic transmission controller code, which is a fully featured code and constantly updated and tailored to individual needs.

Control programming is done via TunerStudioMS. which is i Full featured software interface used with the MSefi type ECU’s (i.e Megasquirt).

The Software allows some very complex transmssion control paremters to be set and should help exploit the AA80E transmissions Manual mode to its best!

Marty.

 

Disecting the DI system

just some rough notes in how we might control the DI EDU’s

D4-S

 

update on DI fueling and AA80E 8 speed to be used in the Supra

Just a quick update. We have decided to run the AA80E box, along with the IS-F Differential. We will be controlling the box via custom contoller with paddle shift changes.

The DI fueling is still a major headache though i have more information on it now including schematics, wiring, control etc etc

This is the most important part of this swap.
Max Orido decided to by pass DI, and unfortunately it caused major engine failure.
The DI injectors heated up as they had no fuel flowing though them (an inbuilt mechanism for cooling) and caused Det melting one piston, and melting an injector tip in another cylinder.

Marty

 

AA80E 8 speed auto wiring and operational tech info

Again all in PDF format

AA80E-A

AA80E-B

AA80E-C

AA80E-D

AA80E-E

 

IS-F engine + TCM Wiring Diagram and ECU Pinouts

in all its Glory! in PDF formatt mind you,

IS-F ECM Pinout

IS-F Wiring Diagram

IS-F Wiring B (plugs)

Marty

Some DI insight

well still awaiting my IS-F tech doc, but heres the basic control system employed by toyota and lexus on thier DI system..

VVT-IE – some new info on its operation

Trying to get info on the VVT-IE system has been a struggle. This is the latest info that I have been able to find.

 

 

1. System structure

Engine control system
VVT-iE system diagram camshaft control motor assembly

Angle sensor

Engine ECU (ECM)

EDU motor

Crankshaft position sensor

Camshaft position sensor

VVT sensor

VVT-IE system overview

 

2. Command control

VVT-iE EDU control the motor, and feedback the state of the motor to the engine ECU (ECM)
Camshaft control motor
EDT1 VTP

Motor speed and direction of rotation command signal

Angle sensor
EMR1 motor actual speed of the VTS

Engine ECU (ECM)

EDU
EMF1 actual motor direction of rotation of VTD

Motor (12V)

EMD1

Fault information

VTM

VVT-IE EDU ECM comms

3. EDM1 – VTM is the diagnostics line between EDU and ECU. Uses a PWM control to relate to ECU and problems.

VVT-iE from the ECU error conditions the duty cycle

Camshaft control motor

VTP and EDT1 open to 100% the Speed ​​Motor and the Rotation 80% normal EDT1 of the Direction the Command the Signal the VTP EDU overheating, 60% motor voltage failure

Engine ECU (ECM)

EMR1

Angle sensor fault Actual, Motor Speed

40% of VTS 20% of VTD

Rotation, the Angle Sensor EDU Motor (12V)

Motor overcurrent protection mode Actual Motor Rotation EMF1 Direction EMD1 5V

VTM

Fault information

VVT-IE diagnostics line

 

So now at last, we are getting a better understanding of the components

 

Marty

 

D4-S fueling system and a 11.8:1 compression

What we want to tame :-

 

The 2UR-GSE engine has Lexus D-4S stoichiometri c, four-stroke, direct-injection technology, which combines the strengths of high-pressure direct petrol injection and low-pressure port injection.

The system mixes and matches fuel delivery from the two sets of injectors to provide the ideal fuel/air mixture for all engine load conditions.

It helps optimise performance and fuel economy, and minimise emissions.

D-4 direct injection, as used in Lexus GS 300 and IS 250 engines, boosts torque across the engine revolution range.

The D-4S system used in GS 450h, GS 460, LS 460, LS 600hL and IS F further boosts torque across the range.

The two injection systems have their own fuel supply systems.

When the engine is running under medium-to-high load at lower engine revolutions, both systems are used.

This creates a homogeneous air/fuel mixture to stabilise combustion, improve fuel efficiency and reduce emissions.

In high-load situations the engine uses the direct injection system only, taking advantage of the cooling effect of injecting fuel directly into the combustion chamber and hence improving the efficiency of each charge.

The precise injection control also allows for a high compression ratio by reducing the chance of pre-ignition or detonation.

The IS F D-4S dual injection engine has a compression ratio of 11.8:1, compared with 11.5:1 in the direct-injection GS 300, for better performance.

When the engine is cold, the injection system uses both sets of injectors to ensure quick warm-up of the catalyst and hence optimum purification of exhaust emissions.

Lexus has reduced the size of the port injector body, to provide optimum cross-sectional area for the inlet port.

 


Direct injection hardware:

The direct injection equipment in IS F’s new engine includes compact, high-pressure double slit-nozzle injectors to maximise fuel atomisation.

The injector atomises fuel into a fine mist and expands it to form a large, fan-shaped pattern in the combustion chamber.

This occurs as the down stroke of the piston draws in a large volume of air. The cooling effect of the fuel increases the intake air volume and improves charging efficiency.

Importantly, the intake air forms a vertical swirl current (tumble current) to promote improved air/fuel mixing and hence improve performance and emissions.

The injector has a special coating on its nozzle to resist deposits.

The area where the injector body meets the cylinder head has an insulator, and the injector shaft has two Teflon-coated seals – to resist cylinder pressure, improve sealing performance and reduce vibration.

 

 

Cam timing – Dual VVT-I and VVT-IE explained

The IS F 5.0-litre Quad-Cam V8 engine has an intelligent electric controlled, continuously variable valve timing system on the intake camshafts.

The electric inlet camshaft actuation system – known as Variable Valve Timing – intelligent Electric, or VVT-iE – improves engine performance and fuel efficiency, as well as reducing emissions and engine vibration.

The IS F engine also has intelligent variable exhaust camshaft timing, with hydraulic activation.

The dual VVT-i system is designed to continually optimise intake and exhaust timing, according to engine load, temperature, revolutions and throttle position.

It offers benefits across the engine revolution range, including increased low-end torque and higher top-end performance – the latter by making optimum use of the ‘breathing’ advantages of valve overlap.

Lexus dual VVT-i also contributes to a significant reduction in exhaust emissions, such as oxides of nitrogen (NOx) and hydrocarbons (HC).

Lexus developed electrically controlled VVT-i to provide additional benefits and greater valve timing control.

Hydraulic VVT-i cannot operate below 1000rpm or when the engine is cold.

However, the VVT-iE system will operate across the full engine revolution and temperature spectrum, with a cam response speed of some 50 degrees per second in the retardation phase and 150 degrees per second in the advance phase.

The Lexus 2UR-GSE engine in IS F has a range of 40 degrees of inlet camshaft timing variation (relative to crankshaft angle) and 35 degrees of exhaust camshaft timing variation.

It can vary valve overlap (the period when both the exhaust and inlet valves are open) from a minimum minus 10 degrees to a maximum of 65 degrees.

The IS F inlet cams have 248 degrees duration and the exhaust cams have 244 degrees duration.

The Quad Cam 2UR-GSE engine has separate primary cam chains to drive the inlet camshaft in each cylinder head, and secondary chains to drive the accompanying exhaust camshaft from each inlet cam.

Lexus now offers dual VVT-i engine technology in eight models.

The new-generation dual VVT-i Lexus Quad-Cam engines meet the previously conflicting goals of:

improved torque at low revolutions, and

better use of the expansion ratio in the cylinder and exhaust pulsation to improve engine breathing at high revolutions.

The dual VVT-i system boosts torque at both low and high engine speeds.

It makes full use of exhaust pulsation to increase cylinder filling at high rpm.

The engine ECU controls camshaft advance and retard, via electric motors for the inlet camshafts. It controls exhaust camshaft timing via an oil control valve mounted on the cylinder head and vane-type actuators on the ends of the exhaust camshafts.

There are five main dual VVT-i operating scenarios.

Engine idle: inlet camshaft neutral position, exhaust camshaft on full advance. This eliminates valve overlap, thereby reducing volume of exhaust gas blowback into the cylinder and inlet ports – for stable combustion and improved fuel economy.

Low engine speed range with light to medium load: inlet timing is retarded and exhaust timing is retarded for increased overlap. This creates two parallel effects: increased internal exhaust gas recirculation rate to reduce oxides of nitrogen and re-burn hydrocarbon, and reduced pumping losses and hence improved fuel economy.

High-load range, low-to-medium engine speed: inlet timing is advanced to close the intake valve earlier, reducing the volume of intake air blowback into the inlet ports and improving volumetric efficiency.

High-load range, high engine speed: inlet timing retarded, exhaust timing advanced. Retarding the inlet timing (according to the inertial force of the inlet air) improves volumetric efficiency and hence power.

At low temperatures: Retarded intake timing and exhaust in the full advance position, to eliminate valve overlap to the intake side. Fixing the valve timing at extremely low engine temperatures – and controlling the range as the temperature rises – stabilises fast idle and improves fuel economy.

Yamaha – behind all the great head designs

Below is the technical document produced regading the 2urgse head. There are many advances in the design of this head. Some of these include oil scavenging pump for heads, direct cylinder and port injection, dual VVT-I and dual VVT-IE, tuned equal length runners in plenum, hollow mirror polished cams and valve train, Titanium valves and more..

 

VVTI-E

 

Head

 

 

Intake Plenum

click here to open the PDF

yamaha tec doc

Auto to manual….

 

Well in Prep for a manual Conversion the first step is to find a suitable bell Housing, and the one below may be the answer. The IS-F 8 speed is a one piece design case so looking at other similar ‘ur series’ engined vehicles the TOYOTA SEQUOIA 4600CC 32-VALVE DOHC EFI, AUTOMATIC 6-SPEED SR-5 Model seems to be a good candidate.

Part no. 351110C030

 

 

http://www.villagetoyotaparts.com/images/parts/toyota/fullsize/357234.jpg