I am wondering what I will need to create a batch to sequential fire converter?
I do not think this will be complicated, though some say otherwise. Initially I would like to keep it simple, and build on it as I go. As well as maybe adding some monitoring or output features. Below are the important factors and what I'm thinking.
I would like to take the current batch ground signal for all 8 injectors, and convert it into 8 separate sequential injector fires.
To do this I will cut the ground wire to the injectors and divert it to the arduino at an analog signal input. This signal can vary from say 1 to 100 ms. The board with then take that signal and send it out individually to the injectors 8 separate times at designated delays. Each ground signal for the exact same length of time as the original input signal.
The trick of course is changing the time between the 8 fires according to the engines RPMs. The nice thing is that I am not trying run a complete fuel injection system, I am just modifying what already works. So the way I see it is that if I take the time between input signals and divide that time by 8, it will give me the time between individual injectors fires.
example... if the input signal is 4ms and the signals are 80ms apart, then I would need to fire each individual injector in the correct order for 4ms at 10ms apart. This seems like a simple program/calculation to me... yes?
The injectors are high impedance, and according to what I understand, I need about 1 amp for each injector. This then means that the arduino board itself cannot handle the current flow to fire the injectors and will need a simple but separate driver board with 8 relays.
I went to college many many years ago for programming and writing code. I leaned to program in Pascal, PL 1 , and other languages but never used it again. But... I am confident that part will be easy after looking at examples in the learning center.
obviously there are a lot more variables, but I believe it's very easily do-able.... what do your think?
***** update**** here is a you tube link ... - YouTube
can someone help me with converting the ground pulse in to a number on the arduino. I need to measure the length of the pulse in micro seconds and the length of time between the pulses... thanks
if the input signal is 4ms and the signals are 80ms apart, then I would need to fire each individual injector in the correct order for 4ms at 10ms apart.
Yes, it would seem straight forward ... Until tonight, I did not know there was such a thing as batch fuel injection, but Wikipedia came through and since I donated again this year, I feel good about the research.
} // end of soap box
The Arduinos run at a 16MHz clock so internal instructions (each clock cycle tick) is 1/16,000,000 second = 0.0000625 milliseconds (ms) = 0.0625 microseconds (µs).
On the other hand, at the user code level, 4uS is usually the maximum resolution and Arduino code rarely translates into a 1::1 assembler instruction. But, with clean coding, you should be OK.
I would think relays would be the wrong switch mechanism; my thinking runs to power FETs... But there are drive considerations there as well. I am sure other members with expertise in the high-current inductive drive area will chime into the discussion.
I remembered a little bit ago that I do not need 8 relays, or whatever it is I end up using, for firing the injectors. The injectors can be fired in pairs. This means I will only need 4 drivers and a bit less code.
to provide a little more information I looked at one of my data logs using 36lb injectors. At 5000 rpms with full throttle the injectors are at 80%, and are firing for around 8ms. At 2000 rpm cruise they fire for about 2ms.
Hi, I can see what you are trying to , to increase efficiency by opening the injector at the time the inlet port is open instead of all injectors open and only one port being open.
Note that the length of injector pulse is also dependent on battery voltage, lower voltage = longer open time , higher voltage = shorter open time. I'm not sure if there is any current sense to.
This is because the mechanics of the injector is constant but with different supply the opening time is different. Yes even from 12V to 13.8 to 14.1V the response is significantly different and times are adjusted.
You would need to measure the batch pulse then use it to output in sequence to each output, synchronising needs you access to the TDC sensor and to know its offset.
Have you looked up the circuity required to drive an injector?
Tom
I will not have to figure out any of the injector timing, or pulse width to the injectors. I will only have to match the timing of the current pulse. The current fuel injection system works pretty well. At this I just want to create a simple sequential converter. There are multiple reasons why, but its not important in the discussion at the moment. In the future I may want to shorten or lengthen the pulse to a particular cylinder. Due to the design of the intake some cylinders run a bit richer or leaner at certain rpms.
The injectors always have power supplied to them while the engine is on, and fire by being grounded. They are high impedance injectors, so there is no resistors or anything needed inline. I am a very good mechanic, and pretty smart, but a total newbe to arduino and to designing/building something like this. I'm looking for advice on what arduino or other board I should use, and what SSR, FETs, or other type of setup I should use for switching the injectors to ground. Speed and accuracy being a major concern.
victor25:
Yes I saw that, and realize those relays are too big, but would this kind of board work well in the correct ssr format?
Well there are a few SSR designed to work with DC output circuits but they are of a minority. Actually such a module is nothing more then transistor output stages matched to an opto-isolator input stage.
You will need to find some way to know which cylinder is on the intake stroke, usually it is done with a cam position sensor, but batch fire injector systems usually don't have a cam position sensor. If your car uses a distributator you may be able to sense spark and offset the trigger of the injector advanced by one in the fireing order with a slight delay. Larry
So I went to radio shack today and bought a Arduino micro, a breadboard, pkg of npn 2amp transistors, and 8 5v LEDs to start writing and testing code. I plan to monitor the ground/ firing signal from the cars ECU at A0 on the micro for both length of pulse and time between pulses. Then use A1-8 for the transistors to fire the injectors. Initially I will use LEDs in place of the injectors for testing purposes. The LEDs should flash in pairs and in the designated order with appropriate delays. The delay will the the time between the A0 signals divided into 4 outputs. So as the time A0 signal length times change the LEDs will match that time and as the time between pulses quicken, the time between the 4 fires will also quicken.
The injectors currently fire 2x per engine cycle or once per crank revolution. So I don't need monitor the crank or cam signals or worry about knowing when tdc of cylinder 1 is, I just need to figure out the best timing and order for firing the injectors. I do know the firing order of the engine, so at this point I will just follow that and attempt to time one of the 2 injector fires with the valve closed, and the second as the valve opens.
victor25:
I don't need monitor the crank or cam signals or worry about knowing when tdc of cylinder 1 is, I just need to figure out the best timing and order for firing the injectors.
Note that fuel rails aren't perfectly regulated and you will probably find that the flow characteristics when you fire a single injector are different to when you batch fire them.
You didn't say what your engine configuration is. If it's a V configuration it wouldn't be unusual for the two banks to be fired separately. When the batch firing is triggered from a distributor (which is also common) then the phasing between the engine cycle and the injection pulses will be determined by the orientation of the crank when the first firing event occurs, so it can vary each time you start the engine. If you have a straight engine, you probably only have one bank to worry about but still have to understand how the injection timing is generated to know whether it's going to be consistent.
Sequential injection is only useful when the duty cycle is kept small, so if you keep the stock injectors the benefits would reduce as the load and RPMs increase. Being able to tune each cylinder individually will always be useful if you have mixture variations, but taking advantage of that capability will be complicated - the most sensible solution would be to adopt an ECU which supports per-cylinder tuning, in which case the batch/sequential conversion issue becomes irrelevant.
I am working on a Porsche 928, which has a 5.0 liter v8. We make a supercharger kit for the cars which take the it from the stock 316hp up to about 500hp. When installing the supercharger, the fuel rails are modified and changed from a flow through design to dead ended rails, and we put in larger injectors. This has caused a resonance in the fuel rails at 2800 rpm because of the batch firing. All eight injectors fire at once. We do have the ability to fine tune the cars fuel maps, ignition timing, and many more things. I would also like to have the ability to fine tune the individual injectors, and this will give us the ability to do that.
A fuel rail accumulator would be a sensible option, then.
Are you proposing to use the batch-fired system to set the average fueling, and the Arduino-based add-on to tweak individual cylinders up and down? That seems a rather complicated/fragile approach with two systems to install, maintain and configure. Given the investment on the mechanical side, I'd have thought a sequential-capable ECU would make financial sense. I recommend going for one with per-cylinder knock detection, too. That's something I'm missing on my setup, and it makes knock detection/avoidance much harder to do well - I only have block level knock detection so it isn't synchronised with the firing events and doesn't enable me to manage each cylinder.
I already have a damper on the system, which surely helps but does not resolve the problem. I am re-modifying the fuel rails to resolve the issue and bring it back closer to the stock setup.... BUT I would very much like to accomplish this!!
I have my Micro up and running with some basic, but good starter code, that fires the injectors at the desired 1/4 intervals. Problem is I am only using a pots to supply my 2 sensor values at the moment. . I need to figure out how to quickly and accurately measure the length of a ground pulse and the length of time between the starts or ends of the pulses. Once I have those 2 variables, I can apply them to what I have and fire up the car
The pulses vary from 1 to 10 ms in length, from like 500ms down 10ms apart. Could someone help me with the code for picking up this data?
If you don't mind your code blocking for the duration of the incoming pulse, you could use pulseIn(). That's a pretty undesirable thing to do, though, and it would be better to use an interrupt handler to detect the start and end of each pulse and measure the elapsed time between them. The scheme is that you would condition your incoming signal to produce a clean 0V/5V pulse, connect it to a pin that supports external interrupts and use attachInterrupt() to trigger an interrupt handler when the input state changes. In the handler you would read the current state of the pin. If it is at the start of the pulse, record the current value of micros(). If it is at the end of the pulse subtract the previously-recorded value of micros() from the current value to get the pulse length in microseconds, and save that to a volatile global variable. All time values should be stored as unsigned longs.
In your main code where you read the current pulse length from the volatile variable you would need to disable interrupts, copy the value to a local variable and re-enable interrupts. That avoids problems where the interrupt tries to change the value at the instant your code is trying to read it.
You will need a pulse generator to test the input pulse detection. If you have two Arduinos you can use a simple 'blink' sketch to toggle an output pin and generate a pulse. If you don't have a sparew Arduino, you could use 'blink without delay' to have your sketch generate the "input" pulse itself, and just connect that output back to your interrupt-capable input pin. My previous post outlined how I'd implement the input pulse detection/measurement.
Im pretty new here so a quick intro. My background is mostly in building and tuning cars. I'm starting to learn programming and am in the process of building a sequential injector tester/cleaner circuit with an uno to start learning coding. I found this post looking for sequential injection code for the fuel injector tester/cleaner im working on.
Im not sure if you mean reading the injector frequency and duty cycle software side or if you mean the electrical side of things. Electrical side you should be able to use a pull up resistor to 5v or 3.3v depending on what you want for signal level and use the injector driver in the ecu to pull it down to ground to make a usable/readable arduino friendly square wave. The car's ecu may freak out for not seeing the other side of the "injector" at 12 volts, but if its a batch fire system it probably will be clueless to whats going on and will just try to fire the injector driver. If it does freak out about not seeing 12v there you may be able to do a voltage divider circuit with 12v and still get a usable square wave. You may need to run a 14 ohm pull up resistor depending on what the stock ecu uses for a driver. 1k is where i'd start though for a pull up.
There is a lot of electrical noise when a field collapses, automotive electrical systems can see 80v spikes when say a starter solenoid lets go. I'm not sure if you have to worry or not on the ground side of things though. Just keep it in the back of your head when connecting in to stuff.
Im not sure how helpful this will be but the mpguino reads injector pulse to keep track of fuel mileage. The mpguino code may give a hint for you of where to start. I have the electrical and conceptual side pretty good. Pretty clueless on the coding so maybe it wont help.
If you are running low ohm injectors you may want to run a lm1949 with its required circuit for each to control amperage to the injectors for peak/hold. Higher ohm injectors should be pretty easy to run.
Hopefully this is a bit helpful, go easy on me, im new here
