X86 for ECU

[John Dammeyer]

Hi all,

This has been an interesting thread and I'd like to add my 2 cents worth based on my
experience developing an ECU for Honda engines that no longer have a distributor.

I used an 8051 varient running at 16MHz so the instruction speed was 0.75uS.  The 80C592
processor was well suited to simple fuel injection because it had a specialized T2 timer
targeted at engine control.  When the timer expired it could set/reset an output or toggle
a couple of different outputs.  This means that once the timer was programmed the output
would automatically change once the timer expired or matched some value so injection or
spark happened without interrupt latency.  The interrupt caused by that event could then
be used program the timer for the next event.

We also used a dual Hall Effect sensor underneath the CAM shaft pulley with magnets
arranged to create a Grey Code Encoder.  i.e. only one of the two sensor outputs ever
change at any point in time so for 180 crankshaft degrees the software knows what quadrant
the engine was in;  intake Cyl #1 or #3 or #4 or #2.  The hardware also had the capability
of creating an interrupt on input change that latched the current T2 counter on a low or
high transition so for every two engine revolutions I received exactly 4 interrupts and
within the interrupt routine I immediately knew where and when the engine was.

I don't believe the PC timers can interrupt and latch on both edges so you'd have to
develop some external hardware to do this or....

Alternatively,  you could put once sensor in the distributor to signal TDC Cyl #1 and a
different sensor on the flywheeel to create a number of pulses per revolution.  The point
is to accurately determine engine RPM at any point in time and to identify TDC Cyl#1
(Which isn't really needed for simple injection).

There are four special situations that arise while doing fuel injection: cranking,  idle
and running and acceleration.

When the engine is cranking the speed of the engine is variable and precise injection
isn't as critical as getting enough fuel into the engine while the engine is cold.  Once
you know where TDC for Cyl#1 is,  you can count interrupts from the crank sensor to find
the other cylinders and just inject based on the interrupt from Cyl#1 plus N Crank teeth
and leave the injector on at a specific number of counts and turn the injector off when
the counter overflows.

During idle,  precise injection is needed or the idle will be rough but the engine RPM is
fairly predictable so a single timer that interrupts can do what is required for idle,
running and acceleration.

The X86 processors are more than fast enough to respond to a single interrupt and to then
reprogram the timer to create an interrupt some time in the future.  Your mainline process
just needs to create a 'sorted' list of timer events that identify what and when something
is supposed to happen.   A single interrupt based on Crank Teeth can update a global
variable that represents engine speed.

If you use just a Crank Sensor,  you can still inject or ignite.  Using waste spark and a
coil per cylinder the time delay for ignition can be programmed to happen N micro seconds
after BDC of the cylinder pairs.  Except during cranking this will result in a reliable
and fairly accurate timing.  If you are using conventional coils you can start the coil
current at BDC and set the timer to overflow N counts later and when that interrupt occurs
stop coil current to create the spark.  The N count value is based on engine RPM which you
use to index a table for ignition advance and engine RPM you get from the tooth just
before BDC..

For injection, inject in pairs of injectors starting at TDC for a pair of cylinders and
turn the injectors off N counts later.  Now you are injecting every 360 degrees and this
works for injector intervals that exceed the the injector open/close time.  For shorter
times you can alternate which injector turns on and off - it doesn't matter much which
one.  If you have access to Cyl # 1 then it's easy.  As an aside -  due to a wiring error,
for the first few months we were accidently injecting Cyl 2 and 3 at opposite times.  Once
that was fixed the engine idled better down to 600RPM on the Dyno (with a very light
flywheel) and when the engine had a propellor we idled at 1000RPM so never noticed the
problem or the difference.

Recall that the title of this posting was X86 processors and I've only mentioned that the
timer on the PC type motherboards needs to create an interrupt at a certain timer value
and to capture the timer value based on an input edge or change.  More than that (A/D not
withstanding),  it just isn't important what type of timer is there if the processor is
fast enough.  With the 8051 8 bit processor an accurate specialized timer makes things
work.  You can get around that with a simpler timer and a high speed processor like a 486
running 66MHz which can easily do injection and ignition.

But,  if you have to develop a custom ISA board to handle the A/D and signal conditioning
and flywheel or distributor sensors plus drivers for injectors and coil you are almost at
the point of a custom fuel injection computer that would fit in a nice shielded box.  It's
not a lot of extra work to add a more sophisticated processor targeted at ECUs like an
Infinion 165 series or Motorola 68X series with the specialized timers -- one for each
injector and spark plug group.

What I'm saying is that for a stationary engine for experimental purposes an X86 board in
side a PC cabinet is fine but if you plan on driving I'd question the reliability of such
a board under the vibration etc. that occurs in a vehicle.  Just imagine the engine
quiting for behaving poorly just as you pull out to pass someone on a two lane highway
with on coming traffic.  It's just not safe.

Regards,

John Dammeyer



----------------------------------------------------------------------------
To unsubscribe from diy_efi, send "unsubscribe diy_efi" (without the quotes)
in the body of a message (not the subject) to majordomo at lists.diy-efi.org