If you have called to ask for help, one of the things we often ask you is, “Are you using a power inverter to power your laptop?  Do you have your laptop plugged in to the wall?”

There is a reason for this, and we see product get killed every year because of it.  If you don’t want the “why” and just want to know what to do, stop reading after this next line (or skip to the more detailed “solutions” section at the end):

DO NOT PLUG POWER INTO YOUR LAPTOP WHILE YOUR MOATES DEVICE IS CONNECTED TO ANYTHING ELSE, LIKE YOUR CAR!!!

Full Explanation Why

Alternating Current (or “AC”) does not rely on ground to operate, guaranteeing only the difference between two terminals and that the voltage periodically changes polarity (plus and minus “alternating”).  AC is what comes out of the wall in most electric grid delivery.  Direct Current (“DC”) is what comes out of batteries and other DC power sources.  With DC, potential stays one direction without changing polarity and voltage produced by a battery is expressed as a positive number of volts.  The negative terminal of the power source is generally assumed to be where you are measuring from when talking about DC.

Ground is not zero volts.  Ground, electrically speaking, is just the place we agree to call zero.  It’s just a convention, a spot to measure from.

AC can have both a negative and positive component with respect to ground.  It can also be entirely positive with respect to ground.  It can also be entirely negative with respect to ground.  As long as the DIFFERENCE between the two AC terminals varies according to specification, they can be valid AC.  For instance, two wires varying between -220 and -100 volts and two wires varying between 50 and 170 volts can both be 120VAC because ((-100) – (-220)) = 120 and ((170) – (50) = 120.  It doesn’t matter that neither of these AC voltages is centered around what we are calling zero volts (“ground”).  In most residential electricity, the “neutral” wire is supposed to be connected to earth ground (literally, a stake in the ground) at the power distribution box but this is not required for AC current to be present – only the varying voltage potential between two points is required even though neutral really is earth ground in most residential electric.

DC is generally (but not always) expressed as a positive voltage with respect to ground.  If you were to reverse your multimeter’s leads and connect the minus lead to the positive terminal of the battery, the chassis (assuming the negative terminal is connected to the chassis) would measure -12V.  The voltage supplied by an ECU to a throttle position sensor is generally 5V, with respect to sensor ground.  If you were to measure the voltage at the TPS sensor +5v supply with your multimeter ground connected to the +12v terminal of the battery, you could expect to see (+5V –  +12V) = -7V instead of +5V.   If you move your multimeter minus terminal to the TPS- pin, you should see +5V between TPS- and TPS+ reference.  The voltage didn’t change – how you observed it changed because of where you chose to call ground.

Ground is just a convention that we agree on.  If you do funny things with ground, you will get strange results.

If you have AC voltage without an explicit ground, you have an infinite number of ways to make DC from it.  In most cases, AC-DC supplies pick a potential in the middle of the AC range and “call it” ground.  They then use electronic components to create a voltage that is always a fixed difference from the AC voltage picked and call this the output.  The AC-DC supply provides BOTH “ground” and “supply” as outputs.  As long as whatever DC load is connected only ever sees these ground and supply terminals, it will operate perfectly as it has a constant voltage potential (DC Voltage).  For most common DC devices (cellphones, laptops, etc.) this is perfectly acceptable because the electrical energy inside the device is largely self contained and it doesn’t need to interface with other devices powered by DC.  For sake of an example, let’s assume that we stick our multimeter minus lead into the ground.  Our AC input measures -60V to +60v with respect to the earth, for 120V total difference.  Our power supply outputs +42V and +30V with respect to the earth.  The difference between the output terminals (+42V, +30V) is +12V, and a 12V DC load would be perfectly happy.

If you have a DC voltage and you want to create a AC voltage, there are also an essentially infinite number of possible ways to do it.  As long as the difference between the outputs measures appropriately and the signal switches like it should, an AC device should function correctly.  If we agree that ground is the negative battery terminal, our power inverter plugged into a cigarette lighter socket on a vehicle receives +12V and 0V from the battery.  It can output a voltage that swings between +120V and 0V.  It can output a voltage that swings between 0V and -120V.  Both of these will be A-OK for something plugged into the power inverter looking for AC because the difference between the AC outputs varies by 120VAC.

So what happens when we take our example AC-DC power supply (supply +60/-60: receive +12V in the form of +42V and +30V) into our power inverter supplying +0V and -120V?  The power inverter is giving a 120V AC output so the AC-DC supply works fine.  The AC-DC supply chooses 18V below max input (+60V – +42V) for its output and 30V below max input (+60V – +30V) for its output.  The AC-DC supply is being fed 0V maximum and -120V minimum.  It outputs 18V below max input (-18V) for its output and 30V below max input (-30V) for its “ground” coming out, which is a difference of +12V (-18V – -30V) so completely acceptable to run our 12V widget that we’ve plugged into the inverter.

But what happens if our widget, powered off -18V and -30V, gets connected by a USB cable to the vehicle?  If we measure all of our supply voltages from the same spot, -30V is a different potential than the terminal of the battery, which we agreed was “0” when we called it ground.  This difference in ground voltage supplied to two devices with a connection in between is called a “ground loop.”  Ground loops happen when two wires that are both supposed to be at the same ground potential get connected together with power supplies driving ground to different absolute voltage potentials.  If you have two power supplies that are trying to push “ground” to two different voltages and you connect them together but they don’t agree about where “zero” is, so you end up with current flowing from “ground” of one power supply to “ground” of the other power supply, trying to equal things out.  Most of the time, the small cables (USB, ribbon, etc.) supplied with our devices which provide the path from one ground potential to the other aren’t cut out for supplying many amps of power than can be supplied by a modern DC power adapter, leading to far more current flowing through wires that were not designed for it.  Heat, smoke and damage are the usual result.

• Car battery (12V and ground), DC-AC inverter plugged in to the cigarette lighter(120V AC out with no common ground reference), AC-DC power adapter plugged in to inverter (+18V and “ground”, with ground floating somewhere between the voltages coming out of the inverter) connected to a Laptop with its USB ports connected to AC-DC adapter ground.  Ground loop forms from AC-DC power adapter “ground” through laptop through USB port through USB cable to device connected to car battery ground.
• Bench power supply (providing 12V and ground) to ECU connected to laptop powered by AC-DC adapter (providing +20V and ground).  Laptop and ECU connected by USB port ground, AC adapter for laptop and AC-DC power supply for ECU trying to achieve different “ground”
• Car battery (12V and ground) connected to DC laptop charger.  DC laptop charger creates 20V to charge laptop but does so with a “hidden” DC-AC conversion coupled with an AC-DC conversion.  DC goes in, DC goes out but ground is “lost” in a hidden AC conversion in the middle.  By the time DC comes out, ground potential has shifted from ground supplied to it.  Ground loop forms from laptop ground connected to floating ground of DC-DC converter and battery ground of car connected to ECU connected together by USB ground wire.

So why don’t you just isolate all your Moates devices?

Solutions for ground loops?

• The standard recommendation is “don’t run your laptop on a charger/inverter.”  This allows ground of the laptop (which is connected to pins on the USB port) to float to whatever potential it is connected to instead of being driven to a certain potential by a charging adapter.
• Another solution is to explicitly tie the laptop’s ground to the power ground supplied to the ECU and link the chargers together, but be aware that whatever wire you use to do this may need to carry a significant amount of current.
• Using chargers which explicitly reference a common ground potential and don’t try to push ground to two different places would be ideal, but it’s often hard to determine how power supplies are designed prior to purchase.
• If you have to use two different power supplies (car battery and inverter+AC adapter, two AC adapters, etc.) use a multimeter to measure the voltage between the ground pins with them plugged in and powered.  If it isn’t zero volts, you’re almost guaranteed to have a ground loop.  You can also unplug everything so no adapter is powered and measure the resistance from one ground to another.  It should be low, ideally zero.  Anything more than a single digit number of ohms is likely to give you a ground loop.
• Using isolated communications is another solution.  These may not be available for all devices but most of our emulators and “active” gear have a 4 pin port for direct communication, which would allow either the BT or Iso options, with an appropriate cable.  (Pinouts are documented.)  The two things we sell to enable this are:
  • Bluetooth interfaces (there are no wires – communications happens over radio energy)
  • The Optoisolator cable. (which uses a device that turns electricity into light to allow communication without an electrical connection)

The ‘Data trace’ feature of our emulators is probably one of the most misunderstood features.  Trace is intended to give you some idea of what portions of an emulated ROM are being used by the target system as a last resort when you don’t have a way of establishing communications for logging.  Trace is a feature supported only by the Ostrich 2.0 and RoadRunner (with latest firmware).  This article exists to document what Trace is, how it works, what it can do, what kind of limitations exist and how it can go wrong.

In order to understand how data trace works, it is necessary to understand the electrical signals used by a microcontroller in your ECU (or target system) to access RAM or ROM using parallel access.  There are many explanations of this out there but this one seemed decently concise.  It will also be necessary to understand the commands used to set up Trace and the mechanism that the emulator uses to gather and report data back to the PC, along with what happens to that data in the application running on the PC.  It will also be very helpful to understand TunerPro RT definition creation.

Bottom line: Trace is complicated, finicky, temperamental and is not designed to provide the same kind of steady, consistent data that can be obtained through communicating with the ECM using some form of data logging.  Our emulators were NOT designed from the ground up to provide 100% accurate address trace data and we do not expect them to be able to deliver that level of performance.

What Trace is and How it Works

Normal operation of the emulator is the PC sending commands to the Emulator to make changes to emulator memory, allowing changes in a “chip” to be made without having to stop, remove, reprogram and reinstall the chip.  The Emulator has a microcontroller which is responsible for receiving and processing commands from the PC and communicating with a memory controller.  In order to allow changes to be made without disturbing the target system, our emulators sneak updates from the PC in between accesses by the target system.  (If the target expects data too fast, glitches may occur caused by collisions between PC and target memory access.)

Trace allows an application that sends the specific appropriate setup commands to the emulator to monitor which addresses the target system accesses.  When trace is enabled, the microcontroller on the emulator starts querying the same memory controller used for realtime updates to see which addresses are queried by the target system.  In order to determine which memory is accessed, two main signals are monitored by the memory controller:

1. The address lines on the emulator, used by the target system to specify which data it wants to see
2. The !OE (Output Enable) and !CE(chip enable) pins, which are used by the target to control the timing of a data output request

After the control lines indicate memory access, the memory controller stores the last address used by the target system.  As fast as it can, the microcontroller retrieves the address information from the memory controller.  Addresses responses are always 3 bytes and take (minimum) 8 MCU clock cycles or around 0.6uS to retrieve from the memory controller.  Setup commands sent by the PC control how the Emulator handles each address retrieved from the memory controller.  It can either store/buffer, send to PC or ignore the received address and wait for another hit.  If you are curious, you can look at the setup command structure in our documentation.  It is possible to control the range of addresses which trigger a match, the number of address hits to gather before reporting to the PC, whether addresses are streamed continuously or reported once before returning to normal control, whether duplicate hits are reported multiple times or once, the format of responses in terms of number of bytes reported and more.

Our emulators communicate with the PC at 921,600 baud 8N1 over a FTDI USB-Serial connection.  This means that approximately 102,400 bytes can be transferred each second, and each byte takes about 10uS to send.  The system is bandwidth-limited because it can gather trace responses from the memory controller faster than it can supply them to the PC.

Software Support

At this point (April 2020) the only softwares that have implemented support for data trace that we know of are TunerPro RT and RenoVelo Domino.  Specific software support for the trace feature is REQUIRED.  An application that supports the realtime tuning / emulation features of our products (i.e. EmUtility) may NOT support trace at all.

While we do not develop it in house, TunerPro RT is our reference platform that we use internally for testing and product development.  There are two methods of using the Trace feature of a compatible emulator in TunerPro RT.

The Address Watch Utility: (Note: it is “greyed out” / unavailable in this screenshot because I didn’t have a compatible emulator plugged in)

Trace can also be invoked to watch individual tables: (again, “greyed out” / unavailable in this screenshot because I didn’t have a compatible emulator plugged in)

Looking at the control protocols, an example auto-generated “T” command sent by TunerPro RT to the emulator to set up trace after clicking the ‘A’ icon appears to be

"54 23 00 00 01 01 08 44 38 08 44 73 BC    /      T#.....D8.Ds."

• Control byte = 23: 0b00100011
• NO streaming
• report only windowed hits
• report all
• normal addr triggers
• relative addressing
• single hit buffers
• single byte address report
• windowed report (relative  vs. absolute address reports)

What can go wrong with Trace? / Limitations

I’m sure Trace sounds great, like the perfect solution for ECUs where limited communication is possible.  Unfortunately, there are many ways for trace to go wrong and not act like you might hope or expect it would.

1. Memory controller limitations: missed hits inside the emulator.  The memory controller does not buffer memory hits.  It only reports the last accessed address.  The speed at which the microcontroller queries the memory controller limits how many hits can be captured.  As discussed, it takes several MCU clock ticks do retrieve data from the memory controller. In ~0.6uS, at least 5x 100nS memory accesses can happen, all of which would be missed by the trace system.
2. Processing received addresses: missed hits inside the emulator.  It takes time (albeit a VERY short amount of time) for the microcontroller on the emulator to process address hits and decide what to do with them.  As it does not query the memory controller when deciding what to do with an address hit, this limits the speed at which it can query the memory controller and limits how many hits can be captured.
3. Bandwidth / PC: missed hits due to serial comms.  This bandwidth and latency limitation is inherent to the hardware design and will not change.  There is very limited bandwidth to communicate with a PC compared to the speed of memory access.  It takes around 10uSec to communincate the shortest format abbreviated address hit in streaming mode.  That means around 100 memory accesses (at 100ns) can occur (and be missed) by the target during the time it takes ONE Trace hit to be communicated with the PC.  Multiple byte responses (which will be necessary for larger monitor windows) will require 2 or 3 times as long for communication.  These are best-case figures, assuming streaming mode.  If a single response is sent followed by a new command setup, the latency of the process could be increased by a factor of 20 easily.  (Note: single response is the default monitoring scheme for TunerPro RT commands.)  If a large number of address hits are buffered and then bulk transferred, the latency between each hit is significantly decreased but the time to communicate with the PC is significantly increased, leading to a longer pause in between each group of responses.  Bottom line: serial communication limits the maximum potential address hit capability to a fraction of bus speed.
4. Addressing mix-ups: software/XDF.   Under XDF … Edit XDF info it is possible to specify chip size, offset parameters.  TunerPro uses the address of the table in the XDF for the start and stop addresses it sends as part of the Trace setup command.  The XDF setup parameters control the relative location of tables within TunerPro’s memory model.  These need to be specified in a way that the addresses TunerPro RT uses for representing the bin on your PC match how the Ostrich stores the bin in its memory.  The addresses matching allows TunerPro RT to match the Trace command responses it receives from the emulator with the correct bytes stored in PC memory and show you which bytes in a table are being accessed.  If the memory models differ, TunerPro RT will never show any bytes in the table being accessed because the responses to the Trace commands don’t match with the information it has in memory.
5. Memory Shadowing: target system behavior: “Shadowing” refers to the practice of an embedded system copying memory from one place to another before using it.  In many cases, slow flash or ROM chip memory is copied to faster RAM memory and then accessed in RAM during normal operation.  In this style of use, there are no ROM accesses to trigger Trace hits after the initial shadow.  While this does not often happen, it is controlled by the target system and is not under the control of our emulators.

Conclusion

Trace was a “nifty extra” added to our emulators because we could and figured it might be handy in some cases.  We did NOT design our emulators around being able to deliver completely accurate and precise address tracing.  We do not have any plans to improve the data Trace feature.  We do not have any plans to release an emulator that has better trace performance.  Our emulators were designed to take the place of a chip and allow realtime changes – this they do well.  Trace should be considered a “bonus feature.”  Do not rely on it to gather all the data needed to tune an ECU.

1. Fake chips.  There are lots of fake 27SF512 chips floating around.  We have a whole article about this.  If you didn’t buy your chips from us, you need to seriously consider this.
2. Bad chip.  Try another chip.  If you have the same results from more than one genuine chip, it’s probably not the chip.
3. ZIF connection. The ZIF socket with the metal handle on the BURN2 is not soldered to the main circuit board.  It’s a press-fit item.  Over time, the action of raising and lowering the handle can work the ZIF loose enough to have issues but not “feel” loose.  Put the burn2 on a flat surface.   Push down on either end of the ZIF with your thumbs firmly to try and re-seat the socket.  Test again after.
4. The solder joints between the DIP32 socket and the PCB can be problematic.  The BURN2 experiences mechanical stress on the solder connections every time you lift or close the handle.  Over time, you’ll crack them.  If you feel like touching up the solder on them, it is often an easy repair.  Try NOT to add any more solder unless you absolutely have to.  The idea is just to melt the solder again so it can bond with the metal pins and circuit board.  This video seemed to be pretty good: https://youtu.be/5F4sX2Pn-Iw
5. If you are still having issues, or don’t feel up to doing the repairs yourself, warranty service may be an option.  Don’t be afraid to try repairs – we’ll still do warranty work on units where you have attempted and failed to repair.  Contact us to arrange for warranty replacement.

Another problem that isn’t as common but we still see are BURN2s that will not erase a chip.  After a “Blank Check” operation, the software reports “Chip is NOT Blank”  There are two strong possibilities for this fault:

1. Fake chips.  The Winbond chips that are most commonly used as fake 27SF512 chips cannot be erased by the BURN2 because they require a different voltage to erase than the 27SF512 chips that the BURN2 was designed for.  If you didn’t buy your chips from us, carefully check to make sure you don’t have fake chips.
2. Defective voltage  circuit in BURN2.  The circuit that generates the erase voltage in the BURN2 can fail.  If it does, you’ll still be able to read chips but erase operations will fail.  This is not something you can easily repair – contact us to arrange for warranty replacement.

1. There is a circuit to keep the QH’s memory using power from the Keep-Alive-Memory voltage supplied to the ECM with the key off. This should decrease the amount that the QH’s own battery is used in cars regularly driven.
2. The BR2331A solder-on battery has been replaced with a socketed CR2032 removable battery. (commonly available)

This version of the QH is shipped without the battery installed. You should install it prior to use.

1. Open bags and unpack everything. You should have a loose battery along with a QuarterHorse module:

Quarterhorse and battery unpacked

2. Turn the battery so the “+” side is facing up. Slide it under the metal spring end of the battery holder.

First, slide the QH under the metal clip side of the battery holder

3. Push the battery gently downwards and toward the metal spring. The end of the battery opposite the metal spring should slide under the brown plastic retaining clip and lock into place.

4. Once installed, the brown plastic clip will hold the battery pretty tightly.  Should you need to replace it, the easiest way to remove the battery is to gently pry on the metal clip with a small screwdriver until the battery clears the metal retaining clip and can be gently pulled out.

Many of our products have physical switches on them to change device behavior.  Unfortunately, we’ve noticed quite a few problems related to these switches.  Over time, sometimes switches fail to behave as you would expect them to.  We suspect this is due to oxidation on the contacts, dust or another slow-acting cause.

Affected Devices

These devices use the switches which are known to have issues:

• AutoProm / APU1
• Ostrich2
• ALDU1

Solution

Fortunately, the solution to switch glitching is really easy.  Sliding the switch back and forth vigorously 5-10 times has been successful in restoring normal operation.

This is intended to provide a brief overview of the steps required to get up and running tuning an OBD1 GM vehicle.  It is deliberately vague.  Instead of providing an exhaustive guide here, there are a series of links to smaller tasks and explanations.  94-95 LT1 vehicles are going to be an exception not covered by this guide as they are tuned via reflash only.  See the 94-95 LT1 getting started page for more.  The “What do I need GM” section is going to have basic hardware and software suggestions for groups of vehicles.

Steps

1. Install chip adapter.  The particulars of this will depend on which chip adapter you have exactly
   • Install G1 adapter: G1 Product page (with install)
   • Install G2 adapter: G2 Install
2. Plug in Moates devices to your PC.  With most modern operating systems, FTDI USB drivers should install automatically via Windows Update.  In the event things don’t go smoothly, look at the USB troubleshooting guide.
3. Download and install tuning software.  TunerCat OBD1 Tuner And TunerPro RT are the usual candidates.  This guide will cover TunerPro RT
   • Install TunerPro RT: http://www.tunerpro.net
4. Download XDF, ADX as appropriate for the vehicle you are working on.
   • TunerPro.net: Definitions download
   • GearHead-efi.com: Ask google gearhead-efi and your mask ID: i.e. for 90-92 F/Y body 1227730, “gearhead-efi $8D“
   • You may need to Convert an ADS to ADX if you can only find an ADS
5. Read your stock chip using a BURN2 or APU1 to get your stock bin OR download one online that should work
   • Gearhead-efi has an extensive archive of many bins: Gearhead Files
6. Load appropriate files in TunerPro:
   • XDF first: Select XDF (this is a map of the tables and parameters to edit in a bin)
   • ADX second: Acquisition… Load Definition (this is a guide of how to communicate with the vehicle and retrieve data)
   • BIN third: File… Open (this is the actual file that goes on the chip, in the ECM, running the vehicle)
7. Configure TunerPro to log:
   • Configure for logging with ALDU1 logging guide
   • Configure for logging with an APU1 also APU1 YouTube Getting Started
8. Get the program you want in the ECM
   • Option A: Burn a chip with the BURN2 / APU1
   • Option B: Realtime tuning
     • With Ostrich2 you will need a SocketBooster for 24 pin applications!
     • 32 pin applications work best with Ostrich2
     • APU1 works for 24 and 28 pin applications with no additional adapters
     • After you have loaded a valid BIN file, disable checksum.  To do this, change the Mask ID from it’s “normal” value (i.e. $8D hex or $6E hex or $0D hex or $42 hex) to $AA (that is “AA” in hexadecimal).  This will allow you to make changes live without angering the computer.  CRITICAL.
     • After you have a checksum-disabled bin, press the blue “up arrow” to load your bin form TunerPro to hardware
     • If you want changes to happen as you make them in TunerPro, click the blue “chip” icon near the arrows to enable or disable emulation.  You should see the status in the lower left change to indicate emulation is active
9. Start logging.  Click the two arrows pointing away from each other.  If TunerPro can connect, you should see the lower status bar change to say “DA: Connected” along with how fast it is receiving data packets in Hertz.
10. Tune the vehicle.

Final Words

If you have prior tuning experience with other products, you may want to look at this article which discusses the differences between more modern tuning systems and TunerPro RT on OBD1 GM.

If you don’t have prior tuning experience, you are highly advised to do some serious reading on thirdgen.org’s DIY PROM board and gearhead-efi.com to get up to speed a bit.

Logging a wideband in TunerPro RT can be a little complicated because it requires simple algebra and a basic knowledge of how ADCs and widebands work.  While there are a few steps, it’s fairly straightforward.  The steps to do this are going to be virtually identical for all vehicles that TunerPro works with.  This article is going to examine the case of adding a Innovate wideband to a A9L computer but the steps could just as easily be (nearly) the same for using an O2 input on a TPI Camaro.  This article will NOT cover building a datalogging definition from scratch so you will need to start with an ADX that can already log the sensor you want to hook the wideband to, such as EGR or one of the factory O2 inputs.
First off – some “golden rules” to follow:

• You should NOT touch the XDF.  All changes will be made on the ADX.
• You will have to edit the bin/tune before starting this to disable the stock functions that use whatever input you are going to hook your wideband to.
• Before starting, you should have the manual for your wideband handy with the voltage -> AFR data handy
• Before starting, you will need to know how the ECU represents analog to digital (ADC) data.  (Most Ford = 10bits, most OBD1 GM = 8bits, Nissan varies by ECU in most cases 10bit)
• Again, this guide will only cover adding wideband functions.  It will NOT cover creating a datalogging definition.

In our example, you will have to disable the EGR in the tune before hooking the wideband up or unpredictable things may result.  If you were using an O2 input instead of EGR, you would need to force the ECU into open loop permanently so the O2 sensors are never used for fuel feedback.

For the remainder of this guide, it will be assumed that you have your ducks in a row and you have the linear wideband voltage output of your wideband hooked to an available, compatible input on your ECU and that you have made any necessary changes to the bin/tune to ensure the ECU does not freak out.

TunerPro Datalogging Definition Internals

Before actually going through the steps involved, let’s look at how a value you can datalog happens.

Fire up TunerPro RT.  Go to the “Acquisition” menu and choose “Load Definition File” and pick a compatible ADX.

Then, “Acquisition… Edit Definition” and click the + next to “Values”

Next, choose the value that matches wherever you have the wideband hooked up (EGR, O2, etc.)  If the value isn’t yet defined, keep reading but understand that you’ll need to track down all the information that would be on the page.  (This generally involves talking to the person who wrote the definition or getting your hands dirty writing one)

The crucial information on this page:

• Title (not circled, at top of page) – this is the “name” of the item that you will see in datalogs
• Unique ID (Blue) – this is a unique identifier for TunerPro.  It has no meaning other than being required to be UNIQUE among all Values you define.  NO DUPLICATES!!!
• Packet Offset (Red) – this is where the value is located relative to the beginning of a data packet, or group of values retrieved at the same time
• Source Data Size (Orange) – this is how many bytes TunerPro should look for in the packet at the Offset for this piece of data.  Note: this may be different from how the ECU represents the data unless the ECU is also using a byte or multiple of a byte sized chunk.

Signed/LSB (Green) – this is information about how the data is represented.  This needs to be correctly configured for the data item by whomever wrote the ADX.

After taking note of these values, click the “Conversion” tab (Circled in Yellow in above picture)

The conversion tab controls how TunerPro gets from the “raw” value that you’ve specified on the “General” tab with the Offset, Size, Data type and changes it into the value you actually see.  At the top, the “Equation” visible defines the math relationship between the raw data and what you actually see.  You can click the ‘Set’ button to change the equation.

You can also specify a transfer function for further conversion of data by looking up raw data within the transfer function to get a result.  This is most often used for things like Air Temperature sensors which have an extremely non-linear output that is hard to fit with a formula.  We are NOT going to cover this further but you should be aware of this function should you have a wideband with non-linear output.

At this point, you’ve seen behind the scenes of how TunerPro handles data logging.

Configuring Wideband Logging

After having a brief tour of behind the scenes of TunerPro logging, you should still be really confused about how exactly to log a wideband.  There are several ways to get a wideband outputting a 0-5v signal to work with TunerPro:

• Edit the existing item corresponding with where the wideband is physically hooked up to use a formula that matches the scale of the wideband.  This essentially “deletes” the original senor and permanently changes it to wideband readings.
• Create a “duplicate” item with a new unique ID that uses the same Offset, Size, Data type as the value corresponding with where the wideband is physically hooked up.  Createa formula to match the output of the wideband.  The original sensor AND the new wideband value will both be available.
• Create a new item with a unique ID that has nothing defined in the data packet but instead uses a linked input where the input is the existing channel data where the wideband is hooked up.  The original sensor AND the new wideband value will both be available.

There are advantages and disadvantages to each of these approaches.  There isn’t just one “right” way of doing things.  Instead of trying to cover everything, we are going to cover creating a “duplicate” item because this method allows us to work with the raw sensor data when building formulas.  Arguably, this is one of the better ways of handling things because you start with RAW data from the ECU, before it has been wrung through god only knows what other formulas.   In the interest of keeping things simpler, we are going to assume that the wideband is putting out a *linear* output.  The original sensor AND the new wideband value will both be available.

Now, it’s time to gather some information:

• Raw datalogged ECU value at 0V input
• Raw ECU value at maximum input voltage
• ECU maximum input voltage
• Number of steps in ECU’s ADC.
• Wideband AFR value at 0v
• Wideband AFR value at maximum output voltage
• Wideband maximum output voltage

You should be able to consult documentation to find “theoretical” values for most of these.  (Note: reality is a bitch and you may need to further tweak “literature” values).  It is generally a good guess that a raw logged value of “0” corresponds with 0 volts.  It is a good guess that the largest number able to be represented by the ADC of your ECU corresponds with 5 volts.  i.e. for a 10 bit ADC, 2^10 = 1024 but we start counting at 0 not 1 so 1023 is the maximum value.  For a 8 bit ADC, 2^8 -1 = 255.  Almost all widebands specify their AFR output at 0V and 5V but you should still carefully pay attention to how these values are specified.

At this point, it’s simple algebra…  Y = mX + b

1. Calculate Wideband AFR range. (Wideband AFR max – Wideband AFR min).  This gives you “rise”
2. Calculate Wideband voltage range. (Wideband spec max volts – Wideband AFR min). This gives you “run” and is usually “5.0”
3. Calculate the ADC voltage range.  (Subtract the max ADC voltage from the minimum ADC voltage)  This is usually “5.0”
4. Calculate the change in AFR per raw ADC tick by dividing the result from #1 by the ADC value range that the ECU can generate (i.e. 1023, 255, 4095, etc.)
5. Calculate the corrected AFR per tick, if necessary.  If the values from #2 and #3 are not the same (common on Nissan – 5.12v max not 5.0v), you will need to multiply the AFR per ADC tick (#4) by Wideband Voltage Range (#2) divided by ADC Voltage range (#5)
6. The equation to plug in to TunerPro to convert raw data will be (X * Corrected AFR/tick) + (AFR at 0 volts)

Concrete Example: A9L with Innovate MTX-L

In this case, we’re going to pretend that we are using an Innovate wideband with a A9L ECU.  First off, we need to create a “clone” of the channel we are going to hook the wideband to, in this case EGR Valve Position.  Look at the original:

Next up, we need to click “Add New Item” (circled in Red) to make a new item and fill it out with the same information as the original EGR Valve Position but with a DIFFERENT unique name.  In this example, you can see I chose a meaningful title (i.e. the name of the item you’ll see in a list while logging) and a minimal description:

In order to figure out how to set up the ‘Conversions’ tab, we need to do math.  Going back to the previous section, our answers to the important questions are something like this (with an explanation of how we know in parentheses):

• ECU value at 0v = 0 (good guess)
• ECU value at maximum input voltage = 1023 (10 bit ADC maximum value, knowledge of ECU hardware)
• ECU maximum input voltage = 5.0 V (good guess, knowledge of ECU hardware)
• Wideband value at 0v = 7.35 AFR gasoline (page 4 of MTX-L manual)
• Wideband value at maximum output voltage = 22.39 (page 4 of MTX-L manual)
• Wideband maximum output voltage 5.0v

Armed with this information we can do math:

1. Max AFR – Min AFR = AFR range.  22.39 – 7.35 = 15.04
2. Wideband Max spec voltage – Min spec voltage = Wideband volt range.  5V – 0V = 5V
3. ADC Max spec voltage – ADC min spec votlage = ADC volt range. 5V – 0V = 5V
4. AFR/tick = 15.04 / 1023 = 0.0147018572825024
5. Result #2 and result #3 are the same so no further correction is required
6. Equation for TunerPro RT = (X * 0.0147018572825024) + 7.35

Phew.  Save.  Go log your minty fresh wideband.

Reality Bites

As was mentioned earlier, reality can often differ considerably from how things “should” be.  So far, you’ve only managed to configure TunerPro for how things “should” be.  Analog to Digital Converters are plagued with issues that affect accuracy.  (Most of them can be solved/greatly improved in the analog realm by having the ECU and Wideband grounded at the same location.)  However even with the best of installs, it’s still very common for things to not end up quite as they are supposed to.  Fortunately, there are a few simple things that you can do to try and increase accuracy:

1. The first step is going to be to make a data item for the ADC channel the wideband is connected to that displays the “raw” channel value – this can be done by changing the item’s formula to simply “X” with no further math.
2. Next, try to get the wideband to display the LEANEST mixture (i.e. maximum AFR) that it possibly can.  This can usually be accomplished by letting the sensor hang in free air.  When the wideband is pegged lean at its maximum voltage output, observe the raw ADC reading for the channel it is hooked up to and the reported AFR of the wideband.  It is not uncommon for the voltage from the wideband to fall a few tenths of a volt (and corresponding ADC tick difference) short of the theoretical maximum voltage.
3. Next, try to get the wideband to display the RICHEST mixture (i.e. minimum AFR) that it possibly can.  This can usually be accomplished by flooding the sensor tip with a torch (doesn’t have to be lit), CO2 / argon bottle, etc. to displace ALL oxygen.  When the wideband is pegged rich to its minimum voltage output, observe the raw ADC reading for the channel it is hooked up to and the reported AFR of the wideband.  It is NOT uncommon to see a couple tenths of a volt (and the corresponding ADC ticks) in the form of a ground offset.
4. Compute the difference between the observed minimum and maximum ADC values.  It will likely be less than the “theoretical” maximum, i.e. 255, 1023, 4095, etc.  Re-calculate the slope based on (Displayed AFR Max – Displayed AFR min) / (observed ADC max – observed ADC min)
5. This process boils down to the same thing as the “paper” version above but instead of making assumptions about how things “should” be you are taking measurements of how they really are.  Using “real” values versus theoretical values can often make the values you log match more closely with the values on the gauge.

Emulation cables link our emulators to a target device.  The Ostrich, Ostrich2 and APU1 all use a similar style emulation cable.  The design of this cable has not changed in many years.  Four standard “shelf” cables are available:

• EMUC2818 is the standard cable supplied with the Ostrich, Ostrich2 and APU1 emulators.  It has a 28 pin chip side (“28″) and is 18” long (“18”) hence EMUC2818
• EMUC2806 is a shorter cable (6″) with a 28 pin chip socket.  It is useful for situations where there is interference with the standard length cable.
• EMUC3206 is a short (6″) cable with a 32 pin chip socket.  When used with an Ostrich2 it allows emulation of a 29F040 4Mbit EPROM.  Adapters can be used to change this to PLCC or other formats.  This cable is NOT compatible with the Ostrich 1, APU1 or ChipExtender – Ostrich2 ONLY!
• EMUC2836 is an extra-long (36″) cable with a 28 pin chip socket.  It is NOT for use with emulators.  This cable is only intended to be used with the ChipExtender product we sell.  Unpredictable results can happen when used with emulators.

The RoadRunner uses an alternative emulation cable which is incompatible with other devices.

Ostrich and APU1 Emulation cables

The Ostrich, Ostrich 2 and APU1 all use the same emulation cables.  These cables have a 0.1″ pitch rectangular connector on one end.  On the other end, a male chip connector is crimped.  Before shipping the cable, we install a machined-pin socket on the cable to protect the more fragile chip connector.

This is how one of the cables looks when we ship it:

As you can see, you can remove the 28 pin machined-pin socket on this cable if necessary:

Replacing a MP socket is much easier and cheaper than replacing a whole emulation cable!

RoadRunner Emulation cables

The roadrunner uses unique cables designed to connect RR hardware with a soldered-on POSOP44 pin header.  Typically, two of these cables must be connected back-to-back for proper operation.

More will follow.

There has been one major firmware upgrade for the QuarterHorse.  There is minimal impact for EECIV users (i.e. Foxbody, 94-95 GT) but EECV users will see a much bigger difference.

What changed?

• EECV 2 bank operation completely changed (affects 96-98 vehicles ONLY)
• Fix to data presentation and corruption during large numbers of incremental updates in low memory pages and program switching (affects EECIV in select modes in Binary Editor ONLY)
• Added support for reading ECMs (All vehicles)

How to Tell If Your Unit Has Been Updated

The easiest thing to do is try and read a PCM, particularly if you already have a stock program read from it to compare to.  If the read operation succeeds, you have 1.6 or newer firmware.  If the read operation fails or does weird stuff, you probably should look into the firmware upgrade.

Upgrading Firmware

Unfortunately, QuarterHorse firmware CANNOT be upgraded in the field.  You can contact support to arrange for an upgrade.  All units with older firmware are encouraged to upgrade, but in many cases (single bank EECIV, for instance) there will be little if any impact to daily use.

On some vehicles, the QH doesn’t work well due to an excessive amount of electrical noise or ground potential differences.  In these cases, the optoisolator module we sell provides electrical isolation between your laptop and the QuarterHorse.  While not a solution to electrical noise issues on the vehicle, it certainly can help.

The main workflow change that this creates is a need to have the QH powered on whenever communicating using the opto cable.  If you need to load a base tune on the bench, you can still plug in to the USB cable directly but you will not have any isolation.  Then again, you shouldn’t need it on the bench.  Please don’t try to have both the Optoisolator interface and the standard USB interface plugged in at once.  It shouldn’t break anything, but it also shouldn’t work.

Install

In order to use the optoisolator interface with the QH, you must solder a 4 pin right angle latching header.  You should have received one with the optoisolator kit.  Email us if you require extra latching pin headers.

First, place the pin header in the QH, oriented as shown here:

Viewed from the bottom:

Next up, solder the 4 pins.

View of completed QH with header for Optoisolator module:

Once the header is installed, simply connect the supplied 4 pin latching header between the QH and the optoisolator module.  Plug the USB end of the optoisolator module in your laptop and get back to tuning.  The isolator module uses the same USB drivers as the QH.

The check sum routine is a piece of the ECU code that checks to make sure the program is valid.  When you use the “Save” or “Save As…” commands in TunerPro, TunerPro updates the checksum automatically.  This is why this is not a concern when burning chips – the checksum is updated when you save the bin.   When you are doing real time tuning with the Ostrich or APU1 Autoprom, it is possible to put the ECM in a “fault mode” by making changes with the vehicle running because the checksum routine interprets the changes you have made as a corrupt chip.  In order to avoid this, you have two choices:

1. Use “Save” or “Save As…” in TunerPro before pressing the “Upload” button so that the checksum gets updated along with any changes
2. Disable the checksum routine prior to uploading.  Doing so will allow you to use realtime chip emulation and make changes incrementally.

Checksum Disable Procedure, In General

The general procedure for disabling the checksum is the same for all OBD1 GM computers:

1. Locate the chip code mask byte. (This byte will be the same as the mask definition you are using in hexadecimal, i.e. $42 for a 1227747, $8D for a 1227730, $0D or $0E for a 16197427, etc.)  This can be called “Code mask” or “Chip code mask” or any number of things in the XDF – there is no standard.  Some XDFs do not even define this byte at all.  It is generally the 9th byte of the ROM for most 28 pin chip ROMs ( address 0x0008h, 04008h ) or the 5th for most 24 pin applications ( 0x0004h )
2. Change the code mask from its default value to $AA in hex ( 170 in decimal)

Specific Example: TunerPro and $0D

1. Locate the chip code mask byte, verify that it is $0D in stock form:
   
2. Change the value from “$0D” (hex) to “$AA” (hex) :
   
   

All electronics will fail with age.  A significant chunk of the failures are due to electrolytic capacitor failure.  These components are virtually guaranteed to fail eventually, even under normal use circumstances.  There are even calculators that can help you estimate how long a given capacitor will last!

So why do manufacturers use these components if they know they will eventually fail?  There really aren’t a lot of good alternatives that have the necessary specifications AND are inexpensive.

Bottom line: all electronic devices that have power supplies generally have electrolytic capacitors that fail.  Ford ECMs are no exception.

A9L Capacitor Replacement

Note: all of these pictures are fairly high res.  If you click them to view the original, you will be able to zoom in for much more detail.

There are three capacitors that typically need replaced in an A9L / Fox Body MAF ECM.

1. First step: Take off all the A9L’s clothes.  Both upper and lower case will need to come off.  These are TORX screws!

   
   

2. Next, locate the capacitors that need to be replaced.
3. 
4. Here is one of the cans, close up:
   

   Even in this extreme close up shot of the base, it is hard to see anything OBVIOUSLY wrong.

   

5. Next step: de-solder the old capacitors.  Like always, we recommend that you use a high-quality de-soldering tool such as the Hakko 808 or a Xytronic 988.  You’ll have a hard time if you try to use a de-soldering braid.  I had to apply a lot of heat and go really slowly in order to achieve solid results.
   Bottom:
   
   Top:
   
6. Next, it’s time to solder in a replacement.
   Bottom:
   
   Top:
   
7. And sometimes when you look a little closer you will see that those caps that looked OK from a distance really had more serious issues…
   
   
8. After you get it out of there, you can see the true mess:
   
   The capacitor really isn’t much better.  It pretty much fell apart being removed.  You can see that it was leaking pretty severely:
   
9. When you have goop on the circuit board, you should clean it up nicely before replacing the cap.  A Q-tip and rubbing alcohol was used here:
   
10. Once everything is cleaned up, solder away with the replacements.  This ECU pictured took about 30-40 minutes to split, de-solder caps, re-solder caps, clean J3 port and re-assemble.

Unfortunately, we can’t give you a straight answer to this.  It’s not because we’re trying to be difficult – it’s because there are a LOT of variables.

Some things that impact battery life:

• How much the QH sits vs. the car runs.  The battery on the QH is only used when the key is turned off.  If you drive the car more, the battery will last longer.
• The temperature that the unit is stored at has a huge impact on battery chemistry.  Self-discharge increases dramatically with storage temperature.
• The temperature that the battery operates at has a huge effect on its performance.  Lower temperatures decrease the useful life of the battery.
• Extremely high temperatures (>60C) contribute to extremely rapid death.
• Batteries discharge while being stored.  We try to buy the freshest stock possible.  We do production runs annually to minimize the time that batteries sit on a shelf prior to being deployed in the field.
• The conductivity of anti-static bags (like what we use to ship the units) is such that sitting on a shelf prior to sale can adversely affect the battery life.  A technote from Panasonic recently highlighted this. (we’ve altered our storage methods to combat this)
• There is a decent amount of variation among individual batteries.

The “show car” in a cold climate (i.e. comes out a few times a year) that stays in an unheated garage is pretty much the worse case imaginable.

For a healthy QuarterHorse, we’ve come up with a worst case figure of about 2.5 years and a best case figure of about ten years for battery life.

The chips (F3, F8) that we sell use non-volatile Flash chips that (at least on paper) have guaranteed memory retention of at least 20 years.

While many people think of the QH as a chip and leave it in their vehicle full time, the QH was never intended to be a permanently-installed piece of gear.  It was intended as an emulator, a tuning tool, something to be tethered to a laptop for use.  In cases where the vehicle will no longer run on a factory computer, a dead battery on an emulator will strand you unless you have a laptop handy to re-load the tune.  Like all of our other emulator products, we recommend that a chip be used for long-term operation.

Please take a moment to check that you have this arrangement correct for your combination. We’re talking about four pins and colors, you can do this!

For TTL-level communications, we use 4-pin latching interconnect cables.  Because of the variety of devices which can be connected, and because we don’t control all of the different as well as legacy production lines and designs, the pinouts vary from one arrangement to another. While this is a complicated mess, it’s not ALL our fault.

This page details most conceivable arrangements and specifies the correct pinouts for each. In many cases, one end is different from another, so it is important to determine what is being connected to which end of the connection. In other words, when you do not have a straight-through cable, it matters which end gets plugged in to which device.

The cables come in 3 different lengths: 6″, 12″, and 48″. The 48″ units are shielded with the black-colored lead, the other two are not (they are short). Thus, it is IMPORTANT to be sure that the black wire is connected to the ground line at both ends when using the 48″ cable. If you instead connect a RX or TX line to the shield (black) line of the 48″ cable, you can have trouble. The other lengths can be more forgiving.

Six different pin arrangements exist currently and we designate them as A-F. The cable for a given combination.can have two ends different or the same depending on the combination, but luckily, there are only so many combos which are realistic.  If you have questions about what you need, contact us.

The Cabling Conspiracy, Documented

The following spreadsheet documents the pinouts of various devices.  If you have a cable made for one device and you’d like to use it on another, you’ll need to move pins around to match the configuration of the new device.  Failure to do so properly has been known to cause premature failure of devices.  Be warned.

This note only applies to older QuarterHorse hardware version 1.3 (fw ver 1.6) units which have the battery soldered to the QH.  Production of this style QuarterHorse stopped around 2016 and was replaced with the current model that features a circuit to draw power from the keep-alive 12V power supplied to the ECM and uses a socketed CR2032 coin cell battery designed to be replaced by the end user.

The battery and circuit on the original QH v1.3 is designed to last 5+ years before needing replacement.  If the BR2330A battery on the QH has become low (<2.0v), the QH will lose its tune memory when the USB is disconnected.  If this has happened, you have two choices:

1. Order a replacement battery (BR2330A-GAN $3 from us, also available from the usual places), desolder the old one and replace it yourself.  You can expect the new one to last about as long as the last one did.  Be warned: this is not a trivial task unless you have the right tools.  Removing the battery without damaging the circuit board requires care.  If you are not comfortable with circuit board soldering, please do not butcher your QH.
2. Use the trade in program for End Of Life Hardware.  (for $100, you can trade in your old QH for a brand new unit with the removable battery)

Checking the Battery

To check your QH, mheasure the voltage of the battery (leads are accessible at the bottom of the QH). Record value (good = 2.5v or better, bad = 2.0v or less typically <1v by the time there is a problem).

Very Old QuarterHorse issues – Manufacturing Errors

Many years ago, a number of QH units were shipped with the incorrect resistor in location R4. This can lead to premature battery drain (less than a year). These units were primarily shipped out during 4Q2012 as a result of undetected assembly error (our bad, sorry!).  At this point (2020) we expect that they’ve all been replaced but this stub of information exists as a historical record.  Please note: less than 1% of QuarterHorses ever shipped had this issue before we caught and corrected it.

In order to determine whether your QH is affected by the manufacturing error, measure the resistance (ohms) across R3 and R4.   The correct resistors will give readings of  R3=1.0k and R4=10k (within 5% or so). If R4 instead measures 1.0k, then the unit is affected and R4 needs to be changed to the correct value of 10k. R3 should be fine at 1k on all units.

Measure the resistances across R3 and R4. The ohm readings should be R3=1k, R4=10k.

If the R4 reading is 1k instead of the correct 10k, then contact us for special RMA instuctions.

Basic Connectivity

The ALDU1 uses a USB connection to talk to your PC.  It uses the same FTDI drivers that all of our other products use.  The first step in getting the AutoPROM working is to get your PC to recognize it.

1. Turn on the computer you want to use with the APU1 and plug the APU1 in to a free USB port.
2. Follow the instructions in the USB troubleshooting guide to ensure the device is recognized by Windows.
3. Although it is mentioned in the guide above, make sure the ALDU1 is using a COM port between 1 and 8!  This is CRITICAL for some older software.
4. The rest of the troubleshooting guides in this guide will assume that you have basic USB connectivity.

Using the ALDU for Logging with TunerPro

Before you will be able to log any data, you need to have the correct ADX definition file downloaded for your vehicle.  The best place to find these is the Definitions section of TunerPro’s website.

With that said, follow these instructions to get everything set up:

1. Make sure the ALDU1 is connected to your PC and has a COM port between 1 and 8.  It will be necessary for you to know which COM port the ALDU1 is using to configure it properly.  Consult the instructions above for ‘Basic Connectivity’ for more detailed instructions.
2. We’re going to walk through the TunerPro RT configuration steps to use this mode.  Your ALDU1 will NOT be recognized by TunerPro RT software like an Ostrich or APU1.  If you’re not using TunerPro, skip to step 8 below.
3. Next, make double check TunerPro’s configuration for logging.  Start by going to Tools…Preferences
   
4. Next, Tab over to the Data Acq. /Emulation tab. (red arrow)  Make sure that “Use Plug-in” is selected for Interface Type.  Make sure “TunerPro Data Acquisition I/O Interface” is selected under the component drop down box.
5. Then click the “Configure Plug-in Component” box (green arrow).
6. Make sure that “Standard Serial” is selected (green arrow) and the COM port of your APU1 is selected (blue arrow)
   
7. IF THE ALDU1 IS UNPLUGGED FROM THE VEHICLE, you should be able to click the “Test For Valid Interface Using Settings” button and get a successful result.  You will NOT get a positive test if the cable is plugged in to the vehicle.
8. If you are NOT using TunerPro RT, you should be able to start your software of choice and configure it to use the COM port of your ALDU1 (COM2 in this example)
9. If you have trouble connecting, check the switch on the ALDU1.  Older applications that use 160baud require the ”10k across A-B” setting.  Later TBI, LT1 and TPI applications use 8192 baud which requires the switch to be in the ”open between A-B” position.

You asked, we deliver!  This tutorial is going to picture the BURN2 but it applies equally to the BURN1 and APU1/AutoPROM as well.

Step by step:

1. Get out your burner and a chip.
   
   Our burners will work with the AT29C256, SST27SF512, AM29F040 and F3/F3v2 chips we sell.
   Our burners will NOT program 27C32, 27C128, 27C256, 27C512 chips but it will read them.
2. Plug the burner in to your laptop’s USB port.
3. Install the chip per directions printed on the burner – the unused pins should be closest to the metal handle.  The divet on the chip used to mark pin 1 should also face the metal handle.
   
4. Fire up our Flash n Burn software.  (If you do not have Flash n Burn, see here to download it)
5. Assuming that your drivers are loaded and your hardware is working, you should see this screen after the software loads:
   
   If instead you see something like this:
   
   “No Hardware Found” means that you should see the BURN2 troubleshooting guide,
6. Next, select the chip type from the list in the upper left hand corner. ( 28 pin = SST27SF512 *OR* Jaybird/BURN2+FA with F3 chip = J3 Ford Adapter)
   
7. Chips need to be be blank before you program them.  Click “Erase Chip” and then “Blank Check”  This will erase the chip and then perform a check to see if it is blank.  If it succeeds, you should see this:
   
   
   If you see this instead:
   
   Try another chip.  If your burner fails to erase several different chips, you probably have fake chips.  If you are sure your chips are not fake, contact us for further assistance.
8. At this point, you have a blank chip correctly inserted in your burner with the correct chip type selected.  The next step is to load the file you want to program to the chip.  To do this, click “Load File to buffer” and then point it at the file on your PC that you want to program.
   
9. Double check addressing settings.  (This can be tricky – there is a whole article on it to help you.)  In most cases, the software will automatically set these for you.  These settings are important because most of the chips used in ECUs are a smaller capacity than the chip you are programming.  You need to make sure the program you put in the chip ends up in the top (end) of the chip, so these settings matter.  A short list of chip addressing settings:
   • 64k bin: 000000 start 00FFFF end ( SST27SF512 chip )
   • 32k bin: 008000 start 00FFFF end ( SST27SF512 chip )
   • 16k bin: 00C000 start 00FFFF end ( SST27SF512 chip )
   • 4k bin: 00F000 start 00FFFF end ( SST27SF512 chip )
   • 56k Ford EECIV bin: 032000 start 03FFFF end ( Ford F3 chip )
   • 256k Ford EECV bin: 000000 start 03FFFF end ( Ford F3 chip )
   • 112k Ford EECV bin: SPECIAL need other software ( Ford F3 chip )
   • 216k Ford EECV bin: SPECIAL need other software ( Ford F3 chip )
   • BEB files CANNOT be programmed with FnB / TP.  Must program using Binary Editor
   • eBIN file CANNOT be programmed with FnB / TP.  Must program using EEC Editor.

   
   

10. Click “Program Chip”  You should see a progress bar march across and then the software report “PROM I/O succeeded.”
    
11. Now click “Verify Chip w/ Buffer”  This will read the contents of the chip back and check them against the program you have loaded in the buffer.  If this test passes, you can be confident that the chip was programmed correctly.
    
    You should see: “SUCCESS:Verification Succeeded” as the message reported back.  If you see this, you are DONE and the chip is programmed correctly!

    If instead you see “FAILURE: Verification Failed (not matched)” you will need to do some troubleshooting:
    

• Check and make sure the chip is inserted firmly in the socket. Remove it and re-insert it to be safe.
• Re-erase and blank check it. If it passes a blank check, try programming it again.
• If it fails the blank check, try another chip.  Failing blank checks is a common sign of fake chips.
• Try another chip purchased from us, xenocron.com, poweraddersolutions.com or another known legitimate source.
• If you’re still having trouble, contact us.

Download link  Download link 2

In order to get a device back into a sane state, you need to CHANGE the vendor ID (which software it is set up for).  Once you have changed the vendor ID, unplug, count to three, plug back in.  You’ll probably have to answer “yes” to a few dialog boxes about setting up the hardware when you next use your software of choice.

The AutoPROM is a complex device and it can be confusing to get up and running.  This guide is intended to get you to the point where you are connecting to a vehicle and able to use its functions.  Before continuing with this guide, make sure you have the computer that you wish to use with the AutoPROM and the AutoPROM itself handy.  For the remainder of this guide, we will use the terms “APU1” and ‘AutoPROM’ interchangeably.

Video Walkthrough

There is a series of videos on our YouTube channel that explain some of the basics. This guide covers a little more material but feel free to look at the videos before continuing.

Basic Connectivity

The AutoPROM uses a USB connection to talk to your PC.  It uses the same FTDI drivers that all of our other products use.  The first step in getting the AutoPROM working is to get your PC to recognize it.

1. Turn on the computer you want to use with the APU1 and plug the APU1 in to a free USB port.
2. Follow the instructions in the USB troubleshooting guide to ensure the device is recognized by Windows.
3. Although it is mentioned in the guide above, make sure the APU1 is using a COM port between 1 and 8!  This is CRITICAL for some older software.
4. The rest of the troubleshooting guides in this guide will assume that you have basic USB connectivity.

A Visual Guide

The APU1 has a lot of switches that controls how it behaves and it is critical to get the switches in the correct position for the device to work.  The following picture gives an overview of the switches and what they do.  (Click to enlarge)

Each way you can use the APU1 will now be discussed.  Refer back to the picture above if you are unclear from the description in each section.

Using the APU1 as a Chip Programmer

The APU1 can be used to program chips.  It functions almost identically to the BURN1/BURN2 products that we sell, using the same software and procedures.

1. Make sure the APU1 is connected to your PC and has a COM port between 1 and 8
2. Make sure the 28 pin ribbon cable used for emulation is UNPLUGGED from the unit. Unpredictable behavior can result from the APU1 being directly connected to a ECM using the emulation cable while burning chips.
3. Make sure the outer horizontal switch is ‘towards the USB port’ position. (APU1 mode. Other position is passthrough mode, identical to ALDU1).  Chip programming software will NOT be able to connect to the AutoPROM unless this switch is set correctly!!!
4. Fire up TunerPro RT or Flash n Burn software.  Your APU1 should be recognized and you should be able to program chips.
5. If the APU1 is not recognized by software, try moving the mode selection switch again.  Verify the the USB is being recognized correctly.

Using the APU1 as an Emulator (realtime changes)

The APU1 can be used as a real time chip emulator.  It functions almost identically to the Ostrich/Ostrich2 products that we sell, using the same software and procedures.

1. Make sure the APU1 is connected to your PC and has a COM port between 1 and 8
2. Make sure there is nothing in the ZIF socket.  Emulation will NOT work reliably unless the ZIF socket is empty!!!
3. Make sure the outer horizontal switch is ‘towards the USB port’ position. (APU1 mode. Other position is passthrough mode, identical to ALDU1).  Emulation software will NOT be able to connect to the AutoPROM unless this switch is set correctly!!!
4. Fire up TunerPro RT or EmUtility software.  Your APU1 should be recognized and you should be able to upload a tune to it.
5. If the APU1 is not recognized by software, try moving the mode selection switch again.  Verify the the USB is being recognized correctly.

Datalogging while using Emulation at the Same Time (logging and realtime changes)

The APU1 can be used for datalogging while simultaneously performing chip emulation.  When used in this manner it is the most capable tools that we sell for tuning OBD1 GM Vehicles.

1. Make sure the APU1 is connected to your PC and has a COM port between 1 and 8
2. Make sure there is nothing in the ZIF socket.  Emulation will NOT work reliably unless the ZIF socket is empty!!!
3. Make sure the outer horizontal switch is ‘towards the USB port’ position. (APU1 mode. Other position is passthrough mode, identical to ALDU1).  Chip programming software will NOT be able to connect to the AutoPROM unless this switch is set correctly!!!
4. Fire up TunerPro RT or Flash n Burn software.  Your APU1 should be recognized and you should be able to upload tunes.
5. If the APU1 is not recognized by software, try moving the mode selection switch again.  Verify the the USB is being recognized correctly.
6. Next, make double check TunerPro’s configuration for logging.  Start by going to Tools…Preferences
7. Next, Tab over to the Data Acq. /Emulation tab. (red arrow)  Make sure that “AutoProm/MAFTPro” is selected for Interface Type.
   

   APU1 tunerpro settings

8. Make sure you have the correct XDF and ADX file loaded for your vehicle, plug everything in and give it a go!
9. If you have trouble connecting, check the other switch on the APU1.  Older applications that use 160baud require the in/up ”10k across A-B” setting.  Later TPI, LTI and TBI applications use 8192 baud which requires the switch to be in the out/center =”open between A-B” position.  If you just want to check codes, the down position will cause codes to flash.

Using the APU1 for Logging Only

As you have seen above, the APU1 is a versatile device that can be used for many purposes.  However TunerPro is the only software that knows how to use any of the advanced features of the APU1, so it is necessary to put the APU1 into a “pass through” mode when using other software.  In these cases, the APU1 functions solely as an ALDL logging interface.

1. Make sure the APU1 is connected to your PC and has a COM port between 1 and 8.  It will be necessary for you to know which COM port the APU1 is using to configure it properly.
2. Make sure the outer horizontal switch is ‘away from the USB port’ position. (Passthrough mode, identical to ALDU1. Other position is APU1 mode for TunerPro.)  Legacy software will NOT be able to connect to the vehicle unless this switch is set correctly!!!
3. We’re going to walk through the TunerPro RT configuration steps to use this mode.  Your APU1 will NOT be recognized by TunerPro RT software in this mode.  If you’re not using TunerPro, skip to step 9.
4. If the APU1 is recognized by software at startup, try moving the mode selection switch again.  Verify the the USB is being recognized correctly.
5. Next, make double check TunerPro’s configuration for logging.  Start by going to Tools…Preferences
6. Next, Tab over to the Data Acq. /Emulation tab. (red arrow)  Make sure that “Use Plug-in” is selected for Interface Type.  Make sure “TunerPro Data Acquisition I/O Interface” is selected under the component drop down box.
7. Then click the “Configure Plug-in Component” box (green arrow).
8. Make sure that “Standard Serial” is selected (green arrow) and the COM port of your APU1 is selected (blue arrow)
9. If you are NOT using TunerPro RT, you should be able to start your software of choice and configure it to use the COM port of your APU1 (COM2 in this example)
10. If you have trouble connecting, check the other switch on the APU1.  Older applications that use 160baud require the in/up ”10k across A-B” setting.  Later TPI, LTI and TBI applications use 8192 baud which requires the switch to be in the out/center =”open between A-B” position.  If you just want to check codes, the down position will cause codes to flash.

“First Edition” AutoPROMs

Very early editions of this unit feature a different switch configuration.

These units have a horizontal switch and a vertical switch.

For the horizontal switch, outbound is passthrough mode and inbound is APU1 mode.

The vertical switch has three positions.  It controls the behavior of the datalogging interface, much like the inner switch on newer models. 10k is the up position, open is the middle position, and short (check codes) is the down position.

These units also use a different style cable to connect the APU1 to the vehicle.  We no longer sell this style of cable.

Among other things, TunerPro RT brings a new definition format, the ADX.  This is an extended version of the previous file format, ADS.  The file formats are NOT compatible, but you can convert between them fairly simply.  Unfortunately, the automatic conversion utility in TunerPro isn’t perfect so this guide exists to help you achieve success.

Failure to set the body length correctly (which this guide will explain) can result in periodic timeouts or errors while logging.  Generally, you will be able to initially connect but there will be seemingly random errors in the data captured.  This seems to be much worse on faster PCs.

Procedure

1. Open TunerPro v5.x
2. Go to Acquisition … Import Definition … From ADS
3. Point TunerPro at the ADS file you wish to convert.
4. When prompted, choose a filename for the new ADX definition (this filename doesn’t really matter, just remember it)
5. Go to Acquisition … Load Definition and point it at the file you just saved.
6. Go to Acquisition … Edit Definition
7. In the editor window, click on the plus next to Commands and then click on Transmit Data Reply
8. Make sure the “Body Size (Dec)” item is 67.  In many cases, it will incorrectly get set to 66 by the automatic conversion tool.
9. Click ‘Save’ and you’re done!  If you ever load this definition in the future, it will be ready to go.

TLDR: If it seems too good to be true, it probably is too good to be true.  If the seller is in China and the chips cost less than $3 each, they’re probably fake.

Update March 2014:  This is now totally out of control.  Less than 10% of the results searching eBay for “SST27SF512” were genuine chips.  They’re now coming in all sorts of shapes, sizes, markings.  The majority of these chips are ONE TIME PROGRAMMABLE chips that have been re-marked to look like the erasable and re-usable SST chips – this means you can program them, ONCE.  After that, the chips will never erase or program again.  Real SST27SF512 chips can be erased and re-used hundreds if not thousands of times.

Increasingly often, we’ve been seeing problems programming chips with the BURN1/BURN2/APU1 because of COUNTERFEIT CHIPS!!!  The 27SF512 chips are no longer being made and have not been in production for quite some time.  (~Aug2009)  I guess we shouldn’t be surprised that counterfeits of these popular chips are now common because Moates purchased the entire final production run of these chips, leaving nothing but counterfeits for other vendors to sell.

Bottom line: If the SST27SF512 chips you purchased did not come from Moates.net, Xenocron.com or one of our other re-sellers, they are probably fake because the legitimate supply of new chips from SST was sold years ago.

Identifying Real Chips

Fortunately, most of these counterfeit chips are fairly easy to spot:

• Most use a white silkscreen print on the top of the chip NOT the laser-etched found on the real deal chips.
• Most have printing on the bottom of the chip instead of  ‘TAIWAN’ embossed in a circle.

Here are some pretty decent pictures of a GENUINE chip for comparison: (click images for full-size)

Fake Chip Gallery

As we receive more pictures from our users of fake chips, we will post them here.

Note the size and placement of the round “dimples” on this fake chip.  Note the whitish silkscreened letters instead of the laser-etched letters.  This is not a real 27SF512 chip.

Note the size of the “dimples” on the bottom of this fake chip.  Note the writing in the center of the chip.  Note the absence of “TAIWAN” in one dimple and the chip ID in the other.  This is not a real SST27SF512 chip.

I’ve seen at least two examples of this fake chip in the past month. (October 2013) They seem to be circulating ebay.  Again, there is a printed NOT laser-etched top, easy to spot and tell:

And “TAIWAN” should not be printed in big letters on the bottom:

1) Get on the website here in the ‘software and drivers’ section and download and unzip the ‘USB Drivers’ file. Remember where you put it.

2) Plug the Ostrich into the USB port of your PC, and point the operating system to the previously located USB Driver directory and install the drivers. See the USB Driver Installation Guides here on www.moates.net for further guidance in this regard.

3) Go into the drivers and set the COM port of the USB to Serial Converter (under Ports in the Device Manager of the Windows Control Panel). Set it to COM3 or COM4. Override any warnings against ‘port in use’ or any of that nonsense. Again, refer to the USB install guides for more info.

4) While in the port settings, set the latency to ‘1’ (default=16). This will speed it up dramatically.

5) Use TunerPro RT or a similar program to upload a binary to the Ostrich, and verify that it is uploaded correctly.

6) Hook it up to the vehicle, and go to town. When installing the ribbon cable where the chip normally goes, orient the red stripe so that it faces where the chip notch or arrow (pin #1) would normally face.

Note: If you have the car off, and the Ostrich is hooked up to the car’s ECU, then sometimes an upload/verify won’t work right. Just turn the car on, or disconnect the Ostrich during the initial upload, and everything should be fine.

There are jumpers inside the Ostrich, depending on how many pins / memory size you are emulating to.
The following pictures illustrate three different ones: 24, 28, and 32-pin. The 32-pin is only used for Ford EEC-V applications right now.

24-pin (with associated pictures for an installation where the original chip was a 2732A in a 1227747-style GM ECM):
Here’s the jumper settings, set for 24-pin emulation:

Here’s the socket that is soldered in the ECM. Note the direction of the notch (to the right) indicating where the original chip pin #1 would go:

Here’s one way to do it, first right before insertion and then after it is snapped down in. Really it is preferable to use a ZIF socket here. Notice the 24-pin socket that is stacked onto the bottom of the regular 28-pin emulation cable. You can just use the 28-pin with the extra 4 pins hanging over as well. Note the red stripe toward where the notch would normally go:

28-pin Installation using the G1 chip adapter, similar to that used in a 1986-92 TPI GM ECM:
Check out the jumper settings. Note that this is the configuration that the Ostrich is shipped with, and works for the majority of the applications.

Note the direction of the notch on the chip, despite the direction of the ZIF handle. This is counter-intuitive for many, and is relatively unique to the G1 / TPI-style adapter due to spatial constraints in the ECM housing:

Now we take the chip out, and put the emulation cable in. Note the red stripe and how it is oriented compared to the notch on the chip that was there before:

32-pin Jumper Settings, presently only used for EEC-V applications:
]]> https://support.moates.net/ostrich-operation/feed/ 0 https://support.moates.net/programming-chips-using-offsets/ https://support.moates.net/programming-chips-using-offsets/#respond Tue, 06 Apr 2010 03:04:49 +0000 http://support.moates.net/?p=775 Introduction

If you’re completely new to burning chips, you may want to take a look at the Beginners’ Guide before reading the rest of this article.  You will probably still need to read this guide in order to choose the correct programming parameters unless you’re in the situation where you’re programming a chip that is the exact same size as the chip you are replacing.  Programming chips with offsets comes into play in two situations:

1. If the chip you are programming is of a larger capacity than the binary file you are putting on it, you need to use an offset to ensure the tune ends up in the right spot on the chip.
2. Switching adapters which hold multiple programs require the use of offsets to fit multiple programs on a single chip for a switching adapter.

Both of these cases will be covered in this article.

Chip Offsets With a Single Tune:

We’re going to assume you have either TunerPro or Flash n Burn open at this point and the chip physically oriented correctly.  If you need help with this, look at the Beginners’ Guide before continuing.  We will be selecting the correct buffer and chip addressing to ensure the chip is burned properly and can be used.

When in the software:

1. Select the type of chip you’ll be programming from the drop-down menu. This will likely be either the AT29C256, 27SF512, AT90F040 or Moates J3 adapter (F3/F3v2).
2. Pick the ‘Load file to buffer’ option, and navigate to the file you want programmed on the chip. Select it, and it will be loaded to memory on the PC. Take note of the file size indicated in the message window. (You can typically “hover” over the filename before opening it and Windows will pop up an information box iwth the file size)  It will likely be one of five sizes: 4k, 16k, 32k, 56k or 64k bytes.
   • The file you have loaded will determine your buffer addressing (start/end)
   • 4k byte = 0000/0FFF
   • 16k byte = 0000/3FFF
   • 32k byte = 0000/7FFF
   • 56k byte = 0000/DFFF
   • 64k byte = 0000/FFFF
3. In the top right part of the window you will see the Chip Addressing offset values that need to be changed. The buffer addressing along with the chip size will determine what offsets you need to use. (Flash n Burn usually automatically selects sane offsets based on your chip type and file size in order to place your buffer at the end of the chip, where it usually belongs.)
   The following table summarizes what offsets you need to use depending on chip used and file size:

   File Size	Chip	Buffer Start -> End	Chip Start -> End
   4k (4096)	AT29C256	000000 -> 000FFF	007000 -> 007FFF
   16k (16384)	AT29C256	000000 -> 003FFF	004000 -> 007FFF
   32k (32768)	AT29C256	000000 -> 007FFF	000000 -> 007FFF
   4k (4096)	27SF512	000000 -> 000FFF	00F000 -> 00FFFF
   16k (16384)	27SF512	000000 -> 003FFF	00C000 -> 00FFFF
   32k (32768)	27SF512	000000 -> 007FFF	008000 -> 00FFFF
   56k (57344)	27SF512	000000 -> 00DFFF	002000 -> 00FFFF
   64k (65536)	27SF512	000000 -> 00FFFF	000000 -> 00FFFF
   32k (32768 EECIV)	F3/F3v2	000000 -> 007FFF	032000 -> 039FFF
   56k (57344 EECIV)	F3/F3v2	000000 -> 00DFFF	032000 -> 03FFFF
   64k (65536 EECIV)	F3/F3v2	000000 -> 00FFFF	032000 -> 03FFFF
   216k or 224k (EECV)	F3/F3v2	“bank” format: non-linear!	convert to 256k!
   256k (EECV)	F3/F3v2	000000 -> 03FFFF	000000 -> 03FFFF

   While the correct values are often selected, you can manually enter them.  For a single-tune single-chip scenario, you generally want the buffer (or file content) to be placed at the ‘end’ of the chip. The notable exceptions to this rule are 32k EECIV Ford tunes (which need to start at 0x32000 and end before the end of the chip) and 216k/224k Ford EECV bins (which are not in linear memory format and need converted to 256k before programming).

   
   To do this manually:

   • Ensure Buffer Addresses are correct for the file size you have loaded.
   • Adjust the Chip Addressing start value and end value until the end value is the maximum value for the chip AND buffer address values are correct.
   • A short list of common chip addressing settings:
     • 64k bin: 000000 start 00FFFF end ( SST27SF512 chip )
     • 32k bin: 008000 start 00FFFF end ( SST27SF512 chip )
     • 16k bin: 00C000 start 00FFFF end ( SST27SF512 chip )
     • 4k bin: 00F000 start 00FFFF end ( SST27SF512 chip )
     • 56k Ford EECIV bin: 032000 start 03FFFF end ( Ford F3 chip )
     • 256k Ford EECV bin: 000000 start 03FFFF end ( Ford F3 chip )
     • 112k Ford EECV bin: SPECIAL need other software ( Ford F3 chip )
     • 216k Ford EECV bin: SPECIAL need other software ( Ford F3 chip )
     • BEB files CANNOT be programmed with FnB / TP.  Must program using Binary Editor
     • eBIN file CANNOT be programmed
4. Once you are satisfied with the offsets, perform a normal Erase/Blank/Program/Verify cycle!  Consult the Beginners’ Guide for more information.

Using Switching Adapters:

Using our switching adapters (G2X, G3, GX, TwoTimer, F3, F3v2,F8) requires programming chips using offsets of making “stacked” bin files.  Switching adapters use chips that are larger than an ECU requires, allowing the extra space to be used for multiple programs.  The “extra” space gets divided up into chunks, each of which can store an individual tune.  There are two approaches to creating proper chips for use with switching adapters, both equally valid:

1. Lump all tune files together on your PC into one bin file “stacked” which is the same size as the chip, program chip at once.
   • The “Bin Stacker/splitter” function in TunerPro can be used to prepare a single file from a group of tunes.  (You can also use a hex editor or other tool)
   • This “stacked” file contains all the tunes and can then be programmed like a “normal” file using TunerPro, Flash n Burn, etc.
   • “Normal” programming cycle: Erase, Blank check, Load tune/buffer, Program chip, Verify.
   • Entire chip gets programmed at once, all tunes for the ECU get programmed on the chip in one operation as part of the “stacked” file.
   • Requires preparation of new “stacked” file and reprogramming of entire chip if any individual tune changes.
2. Program the chip multiple times, once for each tune, different small selected area of chip Program/Verify cycle instead of whole chip.
   • Instead of relying on a program to create a “stacked” file, knowledge of chip addressing is used to place tunes at correct places within a chip.
   • Programming cycle changes slightly: Erase, Blank check happens at very beginning of cycle ONLY ONCE.  Does NOT happen before every Program/Verify operation, like normal.
   • Erase/Blank is followed by multiple Program, Verify operations.  Each operation is for one tune.  Each operation will have different start/end addresses which are a portion of the chip.
   • Does NOT require preparing any special files in advance – uses the same bin files which would be used for single-tune programming.
   • If you want to chance a tune which is already programmed, the entire chip must be erased and all tunes individually reprogrammed.

As a rule of thumb, tunes start at the end of the chip and count down.  i.e. “Tune 0” is in the highest addresses on the chip, or the top slot in a stacked bin.  “Tune 1” will be the next lower slot.  Some adapters have chips which can hold more tunes than there are address lines for switching.

Each switching adapter we sell has different numbers of available slots, slot sizes and corresponding chip addresses start/end:

• G2X: 27SF512 chip (00000/0FFFF), 16x 32kbit/4kbyte slots on chip:
  1. F000/FFFF
  2. E000/EFFF
  3. D000/DFFF
  4. C000/CFFF
  5. B000/BFFF
  6. A000/AFFF
  7. 9000/9FFF
  8. 8000/8FFF
• G3: 29F040 chip (000000 / 07FFFFF), 16x variable size slots, Ex remote required, addressing varies according to settings on adapter
• GX: 29F040 chip (000000 / 07FFFFF), 16x 64k slots, Ex remote required, addressing varies according to size of base file.
  • There are 16 slots on the chip.  Each slot is 64k ( 0x0FFFF) in size.
  • Tunes smaller than 64k typically need to be top-justified so that they END at the end of each window
  • When using the Ex remote (or no switcher – floating switch inputs) slot “0” will be at the end of the chip and bigger numbers on the Ex remote will mean slots closer to the beginning (0x000000) of the chip.
• TwoTimer: 27SF512 (00000/0FFFF), 2x 256kbit/32kbyte slots, idles in “high position”
  1. 8000/FFFF
  2. 0000/7FFF
• F3 (version one – switch pin and 2 tunes): special case.  Cannot program entire device at once, stacking NOT possible.  Program chip twice, manually change state of switching pin during programming. Note: “Erase chip” function does NOT erase whole chip, only erases the “bank” selected by the jumper
• F3v2 (version two – 4 pin connector and dial switch, 8 tunes): special case.  Cannot program entire device at once, stacking NOT possible.  Program chip multiple times, manually change state of switch during programming to select different slots. Note: “Erase chip” function does NOT erase whole chip, only erases the “bank” selected by the switch
• F8: special case.  Use F8 device utility to prepare and program tunes.

It is unlikely that your chip or burner has failed, such events are actually quite rare. All devices are fully tested for all functionality prior to shipment.

We have many folks that send their units back to us, but very few that actually exhibit failure during bench testing once they arrive.

However, it is possible that something is wrong with your procedures.

Please utilize the following test matrix. This should take about 5 minutes:

1) Disconnect all USB devices, close all software, and re-install USB drivers.  See here.  If you suspect that your drivers may be confused, use the FTCLEAN procedure outlined here.

2) Re-connect the Moates device, and allow the drivers to associate with it. Wait about 30 seconds.

3a) Go into the Windows Device Manager, and look under ‘Ports(COM/LPT)’. If there is a ‘USB Serial Port’ listed, right-click on it and select ‘Properties’. If not, carry out step ‘3b’ on this list first.

3b) If you saw the ‘USB Serial Port’ from step (3a) then go directly to Step 4. If not, then expand your ‘Universal Serial Bus controllers’ section, and right-click on the ‘USB Serial Converter’. Go to the ‘Advanced’ tab, and check the box indicated as ‘Load VCP’. Then hit ‘OK’, unplug the device, and plug it back in. You should then be able to carry out (3a) successfully.

4) Go to the ‘Port Settings’ tab and then click the ‘Advanced’ button. Change the COM port setting on the pull-down to COM4, COM5, or COM6, regardless of ‘in use’ warnings. Accept any warnings. If you are running multiple devices (for instance an Ostrich and BURN2), make sure you assign different COM port numbers to each of them. But, make sure your COM port assignments are in the range of COM4-COM8. Also, while you’re on this page, change your ‘Latency timer’ to 1mS via pulldown. Click OK to apply all settings and close all Windows Control Panel sub-windows. If you like, you can unplug and replug the USB cable to the device to verify that it appears in the list with the new settings.

5) Download and install the latest version of Flash-n-Burn from here:
http://tunerpro.net/download/SetupFlashBurn.exe
Note: If you’re working with an APU1, check the back and make sure the horizontal switches are placed in the ‘outboard’ position, away from the USB connection.

6) Download a 64k ‘test’ bin from here:
http://static.moates.net/zips/00-512-TEST.zip
Unzip it, and open the FlashBurn software.

7) Within the FlashBurn software, make sure the chip burner is recognized in the white dialog window. Select 27SF512 on the top left, and load the 64k ‘test’ file to the buffer. Make sure that the file size displayed in the dialog window is 65,536 bytes. If you’re loading a 32k file (like for Hondas etc), make sure the file size is 32,768 exactly.

8) The addressing should auto-select on the top right, but make sure it is correct. Chip addressing should be 000000-00FFFF. Buffer addressing should also be 000000-00FFFF. If you are loading a 32k file rather than the test file, make sure chip addressing is 008000-00FFFF and buffer addressing is 000000-007FFF.

9) Insert the chip into the socket, with the notch (pin 1) facing up toward the ZIF handle and USB cable. Make sure the chip is positioned furthest away from the handle and USB, such that the 4 empty slots are closest to the handle.

10) Select ‘erase chip’ and ‘blank check’. Verify that these steps were successful. Look up again at you addressing, and make sure it matches what is specified in step (8).

11) Select ‘program chip’ and then ‘verify chip’. Make sure you have success in the dialog box.

At this point, if everything checks out, you have illustrated that your chip and programmer are working correctly. If any of these steps fail, please send us a screen capture of the part of the process which failed, and we’ll do what we can to help you troubleshoot further.

Other problems can come from corrupt, incorrectly sized, or mismatched binaries for target application, incorrect chip and buffer addressing for a given file size, or incorrect COM port settings within the client software (such as Crome, etc).

For the burner itself, typical ‘next step’ troubleshooting would include taking apart the enclosure, blowing it out with compressed air to remove any metallic dust that might have accumulated, gently prying loose the ZIF socket to make sure there are no bent pins underneath where it snaps in, trying a different USB cable, trying a different chip, or trying a different PC or USB port.

Certainly if there is a true hardware failure, we’ll be glad to take care of it at no cost, but we doubt you want to spend time shipping back and forth if there isn’t a real hardware fault.

In order to issue you a license for Binary Editor, you must first download and install the software. ( http://www.eecanalyzer.net )  Once you have downloaded and installed the software, go to the “Register” menu at the top of the screen and select “Register Binary Editor”

Next, you will be presented with a screen where you need to provide some information.  First, check the boxes to indicate which hardware you will be using.  Under “Tuners,” check “Moates” for the QuarterHorse.  If you have an Innovate or PLX wideband, make sure you check the appropriate box under “Loggers.”  You will also need to do this for the DataQ standalone datalogger, if you own one.  Finally, put your name in the “Licensed To:” box.  Finally, copy and paste the Machine Code displayed and email it to [email protected] so he can issue you your license.

Note: you will see the machine code  change as you check and uncheck boxes along with changing the name in the “Licensed To:” box.  You must have the same boxes checked and your name typed identically as when you requested your license before you type in the registration key or your “Machine Code” will be different and the registration process will fail!

After you have received an email with your registration key, you will need to open the software registration box again, make sure the same boxes are checked, re-input your name in the “Licensed To:” box so everything matches.  Enter the registration key in the boxes below and then click “Register” – and you’re done!

EEC Analyzer

Download and install the software from http://www.eecanalyzer.net

Go to the “About” tab and click “Register”

Copy and paste the “Machine Code” into an email to [email protected]

When you receive your registration code, navigate back to this screen and enter it in the bottom box then click “Ok.”  Your software will now be registered.

Moates.net F.A.Q

You can use the ALDU1 and CABL2 together for both datalogging and reprogramming. Just get you a free trial version of TTS DataMaster and then get you a copy of TunerCat with the proper definition.

Do I need an adapter to get the chip to fit in my TBI ECM?

For chip swaps on your TBI computer, you’ll probably want to use the G2 adapter. Most folks use an S2 socket snapped into it along with the C1 chip. They’re pretty easy to install, or I can do it for you. The chip you’re looking at comes out of that little plastic holder. Squeeze it gently from the sides, and then use like a jeweler’s screwdriver to lift the legs away from the sides of the holder a little bit. It should snap out of the bottom. Worst case, you can cut the plastic support piece along the back of the chip, and it will come apart much easier. Then you can read the ‘stock’ chip using the Burn1. Key thing though is that to reprogram a chip, you’ll need to use a Flash chip like the C1, and you’ll want to use a G2 adapter to make fitment easy. They are 28 pin rather than 24 pin.

I am using ALDU1 and CABL1 and I cannot get my PC or Laptop to connect to my ecm.

When using it to connect to the 165, make sure the vertical switch (as you look at it to the right) is in the ‘up’ position. When working with the 730, have it in the middle position.

– Under Windows Control Panel, make sure you have the USB/Serial device set up to COM3 or COM4.

– Under TunerPro Tools/Preferences, make sure you have it set up as a ‘Max232/etc’ on the corresponding COM port.

– Under TunerPro ALDL/Datalogging section, make sure you have the correct *.ads file selected. This will either be the 1227165_6E.ads or 1227730.ads file.

What does the switch on the ALDU1 do?

The switch on the back of the ALDU1 changes the resistance between pins A and B on the ALDL interface cable. The topmost position places 10k ohms between the pins. Some ECMs require this 10k resistance in order to connect to the ALDL datastream (some 1227165 are an example). The middle position opens the connection between A and B (infinite resistance). This is the “default” position. Most cars can be datalogged in this position. Cars that require 10k to connect can be switched to this position after connection. The bottom most position shorts the connection (0 ohms). Most GM ECMs dump trouble codes when pins A and B are shorted. This switch position makes doing so simple and convenient when a PC is not available.

What do I need to do to use the winALDL program with ALDU1?

• Set the baud rate to 4800 within the WinALDL program.
• While looking at the ALDU1 box, set the vertical switch to your right, and switch it ‘up’ (10k mode).
• Set the COM port selection in WinALDL to match what it set up to on the USB driver under the control panel.
• Select the ECM type in WinALDL which matches your ECM.
• Make sure the ALDU1 is connected to the laptop prior to starting the software.
• Turn your key off, connect the ALDU1 to the car, and start the software.
• Turn the car on, it should connect.

Does the USB AutoProm require a driver, and if so, where do I get it and how do I install it?

The USB AutoProm does require a driver. You can download it from http://www.moates.net/. Instructions on installation can also be found there. Without the driver, the AutoProm will not function.

Note that the serial version does not require any special drivers.

Is there a users manual for the Autoprom?

Yes, Its on the Moates.net website here.

What does the vertical switch on the back of the Autoprom do?

The vertical switch on the backplane of the AutoProm changes the resistance between pins A and B on the ALDL interface cable. The topmost position places 10k ohms between the pins. Some ECMs require this 10k resistance in order to connect to the ALDL datastream (1227165 is an example). The middle position opens the connection between A and B (infinite resistance). This is the “default” position. Most cars can be datalogged in this position. Cars that require 10k to connect can be switched to this position after connection. The bottom most position shorts the connection (0 ohms). Most GM ECMs dump trouble codes when pins A and B are shorted. This switch position makes doing so simple and convenient when a PC is not available.

What does the horizontal switch on the back of the Autoprom do?

The horizontal switch, called the bypass switch, switches whether the PC communicates with the AutoProm CPU or directly to the ALDL interface hardware. When the switch is towards the serial or USB port, the PC communicates with the AutoProm CPU. This mode is used for changing data in the emulation buffer, for acquiring A/D data, and for ALDL datalogging in “AutoProm” mode (TunerPro only). When the switch is switched away from the serial or USB port, the AutoProm is in bypass mode. This mode allows the PC to communicate directly with the car through the ALDL cable. This allows the AutoProm to function as a simple ALDL cable. Use this mode to communicate with your OBDI vehicle using most ALDL data acquisition software such as WinALDL, CarBytes, Datamaster, etc.

What is the firewire connection on the rear of the AutoProm for?

The firewire connection on the backplane of newer AutoProm units is used for connecting (via a special connector available from moates.net) the 3 channel A/D module.

What chips can I burn and read with the AutoProm?

The Serial and USB AutoProm can read the following:

2732A, 27C128, 27C256, 27C512, 27SF512, 29C256, 29F040, Moates F2A Ford Adapter, Moates F2E EEC reader

The Serial AutoProm can write to the following chips:

29C256, 29F040, 27SF512*, Moates F2A Ford Adapter

* USB AutoProm only

Why does the USB version support writing 27SF512 chips, but the serial version does not?

Because of the simplicity and size of the USB connector, there is more room on the hardware layout for the electronics necessary to write to 27SF512 chips. The serial version does not have enough room for the required components.

What chips can I emulate using the AutoProm?

The AutoProm can emulate virtually any chip up to 64MBit in size (64KB) with 28 pins or less.

What are the 3 additional channels of analog to digital (A/D) conversion for and how can I make use of them?

With the AutoProm, you can monitor and datalog up to 3 channels of analog data. This can be used to monitor external temperature sensors, voltage levels, etc. To make use of the this feature, you need the appropriate interface connector available from www.moates.net. Once connected, you can use TunerPro to monitor the data or datalog the data in the normal ALDL stream (see the TunerPro help documentation).

I’ve hooked up the USB AutoProm to the computer, but the software cannot find or detect it.

The USB AutoProm requires a driver to be installed. See the appropriate question in this FAQ for more information on finding and installing this driver.

Emulation does not seem to work. The SES light flickers and/or the cooling fans come on when I turn the key on.

There are a few things to try or check.

1. Make sure you do not have a chip in the ZIF adapter. At no time other than reading or writing a PROM should you have a chip in the AutoProm ZIF.
2. Make sure your checksum is correct or disabled if your ECM requires it. Checksums can be disabled on GM ECMs by uploading 0xAA to the Mask ID byte.
3. Make sure the chip header is installed in your ECM correctly. Make sure pin 1 is oriented correctly and that all pins are making contact. This may require making adjustments to your ECM chip adapter.
4. If you’re using a C3 ECM (7747, etc), make sure you’ve soldered in your chip adapter correctly. Make sure your car runs as expected from your stock (or known-good) chip.
5. Make sure your emulation header cable is not too long or in a place where electrical interference could be an issue.

After uploading my bin to the AutoProm successfully, verification fails.

There are generally two causes for this: 1) You have a chip in the AutoProm ZIF, 2) Your USB cable is bad or inadequate. Try a different brand or type of USB cable.

I can’t seem to read or write a chip. What am I doing wrong?

Make sure the chip is properly oriented in the AutoProm ZIF. Pin 1 should be towards the back (connection) side of the AutoProm, and the chip should be all the way towards the front of the ZIF, such that any unused pins are between the chip and the ZIF handle.

I can’t seem to connect to my ECM with the AutoProm.

If your AutoProm is in bypass mode and you’re using TunerPro, make sure TunerPro is configured to use “Max232” as the adapter interface. If you’re using a USB AutoProm in bypass mode with WinALDL, make sure WinALDL is configured to use 4800 baud. There are a few ECMs that cannot be connected to un non-bypass mode. Please contact Craig or Mark for more information if you continue having difficulties connecting.

Could tell me how to connect with the APU1/ALDU1 step by step?

• Turn vehicle off.
• Close all programs including TunerPro.
• Connect the APU1 or ALDU1 to the USB port and the vehicle ALDL.
• If using the APU1, set the horizontal switch to the ‘inside’ setting for use with TunerPro. Set it to the outside for use with WinALDL or DataMaster.
• For 8192, if using 1227165 ECM, set vertical switch to ‘up’ position (looking at it with the vertical switch to your right).
• For all other 8192, set it to the ‘middle’ position.
• If you want to ‘flash your codes’ set it to the bottom position and turn the key on.
• For 160 baud (older TBI, etc), set it to the ‘top’ position.
• Open up your Windows Control Panel, under ‘System’ and ‘Hardware’ and ‘Device Manager’ under ‘Ports’. Find the USB Serial Port, and go to the Port Settings tab. Go to the Advanced button, and make sure the COM port setting is either COM3 or COM4. Set the latency to 1. If having connection issues, you might try a latency of 5. Once settings are applied, hit OK and close out all Control panel stuff. Keep in mind that this will be valid and ‘keep’ for the particular USB port you are plugged into for next time. If you plug into a different USB port you’ll need to do this again for that one.
• Open un TunerPro, and go under the Tools/Preferences section. Go to the ALDL/Emulation tab. If using APU1 with the switch to the ‘inside’, select ‘AutoProm’ for datalogging device type. If using the ALDU1 or the APU1 with the switch ‘out’ then select ‘MAX232/etc’ as device type and specify the correct COM port assignment (remember this from the Windows Control Panel exercise, probably COM3 or COM4). Once set, hit apply or OK and close that window.
• Go to the Tools/ALDL-Datalogging/Setup section of TunerPro, and ‘browse’ for the correct datalogging definition file (ADS file). You may need to download it from the TunerPro website. The name of the file should tell you if it’s the right one. Once selected, you’re ready to go almost.
• Close TunerPro and open it back up. That’ll make sure all your options ‘stick’.
• If using APU1 with the switch ‘in’, you should see a message at the bottom of the TunerPro window indicating “Connected: AutoProm blahblah” whereas if you have the switch ‘out’ or you’re using an ALDU1, you will see ‘Hardware Not Connected’ and that is OK.
• Go back to the Tools/ALDL Datalogging/Setup option, and now turn your key on. Click on the ‘Connect to ECM’ button. It should connect. If not, then something isn’t correct or something is wrong. Could be corrupt binary, bad connection, hardware problem, or something else. Some of the older 165 (pre-89) have difficulty, and you may need to upgrade to the 89 (6E) code. Some of the SyTy/late-model TBI trucks/LT1 stuff has problems because of a ‘silence mode’ command requirement. This is being worked, and should be fixed soon.
• Once connected (you’ll see the ‘connected’ indicator), you can monitor variables. Go to the Tools/ALDL/Datalogging menu, and you’ll see where you can show ‘Flags’, ‘Values’, ‘Dashboard’, ‘Traces’, all sorts of user-definable stuff. To choose values for your dashboard display, you can right-click and select something you want to show from a pulldown menu.
• Now you’re up and running. Don’t forget: NEVER disconnect the APU1 or ALDU1 from the PC while the software is open! No damage will occur, but the PC side will hang up and get confused. So, always connect and disconnect your hardware when there is NO software open and running (safe rule of thumb

Once you do all the stuff above, next time all you should need to do is:

• Connect USB stuff
• Connect ALDL stuff
• Set switches
• Start TunerPro
• Turn key on
• Connect and datalog
• When finished, turn key off and close TunerPro session
• Disconnect ALDL
• Disconnect USB

How do I make an ALDL data recording with Tuner Pro?

For ALDL data acquisition the AutoProm has two modes: Passthrough and AutoProm. Passthrough mode is set by placing the horizontal switch on the backplane away from the USB connetor. In this mode, TunerPro must be set to MAX232, since the AutoProm, when set to this mode, is just like any other ALDL cable. To set it to AutoProm mode, place the horizontal switch towards the USB port. In this mode, TunerPro must be set to AutoProm mode. The purpose of passthrough mode is to allow the AutoProm to be used for gathering ALDL data using applications other than TunerPro. In this mode you cannot make changes to the emulation buffer in the AutoProm mode. In AutoProm mode (again, set on the AutoProm itself and in TunerPro’s settings), you can emulate and datalog at the same time.

To record an ALDL data log, see the TunerPro help file, but here’s a summary:

• Connect the AutoProm ALDL cable to your Vehicle
• Set the AutoProm and TunerPro to the appropriate mode (see above explanation)
• Connect to your ECM
• Hit F4 to open the ALDL setup window
• Click “Select Log File for Record/Play” and browse to a file to record to (or enter the name of a new file)
• With TunerPro actively getting data from your ECM, hit the Record button
• When done logging, hit the stop button
• Hit the play button to play back the log you just recorded

How do I emulate with the Autoprom and Tuner Pro?

The TunerPro help file has a step-by-step outline of how to emulate. Here’s a an abridged overview:

• Attach the AutoProm to your PC and to your Vehicle
• Make sure the horizontal switch is towards the USB port on the AutoProm
• Start TunerPro (note that TunerPro automatically detects the hardware)
• Load your bin and bin definition into TunerPro
• Upload the bin to the emulator (see the related menu or toolbar buttons)
• Enable emulation (again, in the tools menu or on the toolbar)
• Start your vehicle
• Make changes to the bin
• Hit “update” in the respective item editor after every change to update the emulator RAM with the new data.

Note that you may need to disable the checksum in your bin. This is done by changing the mask ID byte to 0xAA. More information on that can be found in the various tuning forums, including the forum at www.thirdgen.org/techbb2 (DIY PROM forum).

What do I need to start tuning a Ford?

It really depends on what you want to do and how you want to do it. The F1 and F3 adapters are plugged into the J3 port. You cannot change anything with these while they are plugged into the J3 port, you have to unplug them and use the burn1 to write the modified bin file to the adapter. These adapters “override” the stock programming and allow you to change anything you want ,and get your “tune” exactly where you want it. To do this though you really need a way to datalog, and a Wideband O2 sensor is a great help as well.

The F1 adapter is designed for use with most EEC-IV processors, it doesn’t work with the 4 cyl turbos, and it does not come with a chip. The new F3 works with both EEC-IV and EEC-V processors up to 2003, it is switchable between 2 memory locations , giving you multi-chip capability. It also comes with chip installed and with the optional F2A adapter, can be programmed without removing chip.

You also need some software to be able to edit your bin files, the bin file is the binary code within your PCM. Both Tuner Pro and EEC Editor support Ford stuff and work well with Moates hardware. You will need to make sure there is software support for your particular application.

Another way to tune is with a emulator, basically with this device you can make changes while the car is running, this greatly simplifies the tuning process. Currently Moates offers the Ostrich, which will interface with EEC IV and EEC V PCMs using the FORDEMU. Also the Autoprom will work with only EEC IV PCMs using the F1.

I have a 2.3 Turbo (PC1, PE, PF2, PF3, PK, PK1,etc) what do you have for me?

Typically folks have used the F2 adapter to override their stock EEC program via the J3 port. However, the F2 adapter is no longer available. The F1 adapter does something similar, but it doesn’t work with turbo type applications, only N/A EEC-IV (pre-96) stuff. So, I have the F3 and F4 adapters (single program and switchable). They will be made available soon. They will work with EEC-IV and EEC-V as well as the Turbo EEC-IV.

The Burn1 is a chip programmer, and is used to program the J-3 adapters via the F2A. The F2A is merely an adapter to go from the BURN1 to a chip adapter such as the old F2 or F3/F4. The BURN1 can also be used in conjunction with the F2A adapter. This is being redesigned so that it can be used with the APU1, and will be renamed probably to just the FA. It is used for a couple of different purposes. First, it can be used in conjunction with the F2E to read the ‘stock’ content from the EEC-IV and EEC-V computers. Second, it can be used to read chip modules such as the F1, F2, F3, F4, and others such as the TwEECer. The binary from these exercises can be saved and edited offline. The BURN1/FA combo can also be used (as well as the APU1/FA combo) to program chip modules such as the F2, F3 and F4. This way, you go directly through the BURN1/APU1 interface via the accompanying software and USB interface. No need to remove the chip from the module.

In all these cases, there is no desoldering involved. Just clean the contacts on the J3 port and stick the programmed adapter module (F3 or F4 in your case) in there.

How do I know what bin file I need?

You start by getting the catch code off of the processor (see image), this will be the .bin file name. This one would be a Z2D1.bin

What is a J3 port?

It’s the port on the back of your processor that the adapter plugs into (see pic).

Which way does the chip go into the socket on the adapter?

The top of the socket on the F1 adapter has a notch in it, line it up with the notch on the chip facing the same way, the chip installed all the way at the bottom of the socket(see picture).

What chip addressing do I use when programming a F2 or F3 for EEC-IV ?

When programming for EEC-IV, you want to put a 56k binary from 032000-03FFFF.

What chip addressing do I use when programming a F2 or F3 for EEC-V ?

When programming for EEC-V, use the following addressing:

BANK0: 002000-00FFFF

BANK1: 012000-01FFFF

BANK8: 022000-02FFFF

BANK9: 032000-03FFFF

Does the F2E (EEC computer reading interface) use an external power supply ?

No, its uses the USB port to power the PCM.

Do I have to remove the PCM from the car to use the F2E ?

No, it works either way, either on the bench or in the car.

Is the F2E a stand-alone unit, will I need anything else to read the chip ?

No, it is not a stand-alone unit, it is designed to work with the burn1 and F2A Ford programming adapter.

How do I use the F2E ?

Attach the F2A to the Burn1, then plug the cable that came with the F2E into the F2A, then the F2E to the cable, then plug it into a CLEAN J3 port (see pics below).

What addressing do I use to pull out a bin from my EEC-V ?

When pulling a bin from a EEC-V, use the following addressing:

000000-03FFFF will pull out an entire 256k file with the banks at the following addressing:

BANK0: 002000-00FFFF

BANK1: 012000-01FFFF

BANK8: 022000-02FFFF

BANK9: 032000-03FFFF

Which way does the chip go in to the socket?

The top of the socket on the burn1 is the handle, line it up with the notch on the chip facing the same way, the chip installed all the way at the bottom of the socket(see picture).

My software doesn’t see the burn1

Follow the documentation on setting up a com port and installing the USB drivers in the documentation section on the Moates.net web site here.

Can I use a Wideband O2 sensor in my factory harness?

The wideband O2 sensor itself looks much like a standard O2 sensor. It does in fact install similarly, with the same threads. However, it requires a separate control box. It is a heated sensor which requires special heating rates and such, and can’t be controlled straight off of a factory harness. Instead, what you do is ‘add’ it to your exhaust, keeping the stock O2 sensor in place and adding the wideband sensor at another point in the exhaust system by cutting a hole and welding in a bung. Then for the control box, you use either the LC1 or the LM1. For the LC1, you can monitor it via the laptop and what-not, and for the LM1, it has a local readout which you can view. Both the LM1 and LC1 have a ‘serial’ output which can be used to either hook up to a PC for logging or to a gauge like the XD1.

As a more advanced topic, if you’d like to ‘replace’ your factory O2 sensor with a wideband unit, you can use what is called the ‘simulated narrowband output’ of a unit like the LC1. To do this, you need to splice into your existing harness slightly and program the LC1 to match. The LC1 has two programmable analog outputs, one of which can be used to ‘feed’ the factory ECU.

In any case, the wideband controller (LM1 or LC1) is a critical part which is needed.

Where do I find support for TunerPro software?

At the TunerPro website http://tunerpro.markmansur.com/, Mark has a nice F.A.Q posted there.

Where do I find support for EEC Editor software?

On the EEC editor mailing list http://groups.yahoo.com/group/eeceditor/.

Or check this web page to D/L the software and def files: EEC Editor

Where can I find information on using the Flash & Burn Software for the Burn1?

This information can be found in the Burn1 Use document in the Documentation section of the Moates.net web site.

Where can I find information on Chip addressing?

This information can be found in the Using offsets when programming chips document in the Documentation section of the Moates.net web site.

What chip addressing do I use when using the F2 in a EEC-IV ?

When programming for EEC-IV, you want to put a 56k binary from 032000-03FFFF.

Can the firmware of my Moates.net device be updated?

There are 3 devices which can be reflashed in terms of firmware: APU1, BURN1, and Ostrich.

Whatever you do, do NOT reflash your unit with an update that is designed for another! For instance, don’t reflash your AutoProm with a Flash&Burn firmware. Otherwise, you’ll be sending it back to me. I don’t know how to state this more explicitly. Be careful and deliberate, and DON’T reflash with the wrong firmware! Step by step instructions are below:

1. Download the Firmware updater program and the correct firmware for your application from Moates.net, i.e AP_2_8_A.zip is for the autoprom, notice the “AP” at the beginning of the file.
2. Open up the Firmware updater program, you should see a window like below:
3. Click on the open file button, browse to the directory you downloaded the firmware and select it.
4. Make sure you have the correct firmware loaded before this step! Now click update, you should see this screen when update is done:

The first thing you should do if you are having trouble with the Ostrich is to follow the instructions in the “USB Troubleshooting Guide” which you can find here – for the rest of this guide, it is assumed that your Ostrich has been assigned a COM port and you have selected the appropriate settings for it in device manager.

The ostrich is a ROM emulator – this means that it is designed to look like an EPROM to a target system, like your ECU. If you have a working ROM Burner (such as the BURN1 or BURN2) you can quickly and easily test your hardware. We will be using the BURN1 programmer and an Ostrich 2.0 in the following example, but any ROM burner that can read 27C512 EPROMs will work. The Ostrich 1.0 works identically to the Ostrich 2.0. Follow the “Hardware Test Instructions” to verify that your Ostrich hardware is working correctly.

If you’re reasonably certain that your hardware is working right but you still can’t get the Ostrich working with your ECU / ECM of choice, take a look at the “Software Setup” section for hints and writeups on using the Ostrich with particular applications.

Hardware Test Instructions

1. For this test, download a 64k ‘test’ bin from here:
   http://static.moates.net/zips/00-512-TEST.zip
   Unzip it and save the file somewhere you can find it.
2. For this test, you will need your ROM burner software installed and working. (in this case, Flash and Burn). We will also be using TunerPro RT for uploading files to the Ostrich. Even if you do not usually use TunerPro RT, please use it for this test as it is known to communicate with the Ostrich flawlessly.
3. First check: TunerPro RT should say something in the lower window about finding an Ostrich. If your Ostrich shows up in device manager as a COM port but TunerPro RT does not detect it, you probably have a defective unit and need to RMA it.
4. Next check: The Ostrich2 has different modes of operation for 28 and 32 pin operation, both electronically and with switches. Ensure that both switches are set to the 28 pin position. Make sure the “Emulation Banks” toolbar is visible in TunerPro.
5. The Ostrich should be set for Bank 0 for 28 pin operation. Try setting the Ostrich to Full 4Mbit (or Bank 8 for 32 pin operation) and back to Bank 0 (for 28 pin operation) to be sure your Ostrich is not stuck on an incorrect bank.  It is important to CHANGE this setting, even if it looks correct initially.
   
6. Quit TunerPro.  Download the DORESET program and run it.  (It’s pretty simple and self explanatory.)  Even if you haven’t used one of these programs, it wouldn’t be a bad idea to run this just-in-case an incorrect vendor ID got set somehow.  After you are done, quit the DORESET utility.
7. Re-open TunerPro RT.  Now it is time to load a file.  In order to verify with Tunerpro, you need to first load a XDF  and a binary that *should* work together.  Doing a verify with Tuner Pro without loading a XDF can result in unpredictable behavior.  You can find an assortment of bins and XDFs on TunerPro’s website in the definitions section.  Try to choose a bin/XDF pair where the bin files are the same size as the files you are trying to use.  i.e. 4k, 16k, 32k, 64k
8.  Open a binary file that is the same size as you use in your ECU. Click the button with an up arrow on it to upload the file to your Ostrich. You should see the status bar in Tuner Pro flash as the file uploads. (Note: this will be very fast – under a second usually)
9. Now do a verify in Tuner Pro.
10. TunerPro will automatically update the checksum on a file loaded according to the current XDF before doing a full upload to the emulator.  This can cause a false-failure when you are trying to use a ROM burner to check the Ostrich.  For the next test, we want to disable this behavior.  The easiest way to do this is to go to the ‘XDF’ menu and select “New XDF” which will create a new, blank XDF without a checksum to update.
11. Go to the “File” menu and open your test bin AGAIN.  Ignore any warnings from TunerPro – No you do NOT want to save.
12. Click the “Upload” arrow like you did previously to upload the bin to the emulator, this time with your new blank XDF.
    
13. Disconnect your ostrich’s USB cable from the PC. Connect your ROM burner and fire up its software. Connect the socket at the end of the Ostrich’s ribbon cable in your ROM burner like it was an EPROM.
14. Make sure the switch on your Ostrich 2.0 is set to the appropriate setting for the cable you are using.  if you are using a 28 pin cable, both switches should be towards where the USB cable plugs into the Ostrich.   (the Ostrich1 didn’t have external switches)
15. In your ROM burner’s software, load the same file that you uploaded to your Ostrich using TunerPro RT. Make sure you choose an EPROM that is the same size as the file you are uploading (i.e.  27SF512 for 64k)
16. Perform the “Verify” function. If your Ostrich is working correctly, the Ostrich should “verify” successfully. If it failed to verify on the first try, try again.  Sometimes the Ostrich needs an opportunity to power up before it becomes available.  If your Ostrich passes this test, it is 100% working and you should do a happy dance!
17. If your Ostrich failed the “Verify” in the ROM burner software, try plugging the USB cord from your Ostrich back in to your PC and repeating the Verify test in your ROM burner software. If the Ostrich passes the test when the USB cord is plugged in but it fails when it is unplugged, one of the ground or power pins on the socket is damaged. Carefully inspect the socket for broken pins. Carefully inspect the ribbon cable for frayed or damaged wires. Emulation cables (see here) can be ordered at a fraction of the cost of a new unit.  Also – double check your switches!  Switches can cause the Ostrich to verify with USB plugged in and fail to verify with it unpluged.
18. If your Ostrich does not verify with the USB cable connected to the computer but you did pass the earlier verify in TunerPro RT, there is a problem with the Ostrich communicating down the ribbon cable with the target system. Look at the ribbon cable with the socket VERY carefully. Are there any broken pins? (this is very common) If you are sure that your cable is good but your Ostrich still fails this test, it will have to be RMAed.

Software Setup

How to setup Ostrich in CROME

(more will be added here later)

With that out of the way, you’re looking at this page because your USB drivers are very broken.  You have devices in Device Manager with yellow exclamation marks that cannot load, cannot start or just plain don’t work.  This procedure will forcibly remove everything FTDI related and allow you to start over with a clean slate.

1. Step one: download FTCLEAN from FTDI’s website – link
2. Step two: unzip the file into a directory on your computer.
3. Step three: run FTCLEAN.EXE
4. Step four: click “Clean system” then click Yes to confirm
5. Step five: REINSTALL FTDI DRIVERS!!!  You should be starting from scratch.

Almost all Moates.net products have a USB interface to connect to a computer. (ALDU1, HULOG, Hondalog, BURN1/2, Ostrich 1/2, Roadrunner, Quarterhorse, Jaybird) Fortunately, all Moates.net products with a USB interface use the same USB support chip so they can all use the same drivers. This makes it easy for you – one driver install will take care of ALL Moates products! Check out USB Driver Installation for more on how to reinstall drivers.

The chip in our devices is made by a company called FTDI. This chip is VERY common and is used in everything from USB-serial and USB-parallel adapters sold in computer stores to other automotive electronics products. This is important because of the possibility of a driver conflict between drivers for your Moates.net devices and other devices that also use the FTDI chips. AEM FIC, Hondata S300 and K-Pro and the USB Instruments Stingray and Swordfish (among others) have a tendency to obliterate our drivers and cause driver conflicts. Be warned: the troubleshooting instructions later on this page may cause other devices that use the FTDI chips to stop working. Tip: If you start having driver conflicts, installing the latest drivers from FTDI will often be enough to resolve conflicts and make everything work again.

Making Sure Everything is Working and Configured

First step to making sure you don’t have a connection issue is to unplug all USB devices that are not absolutely necessary from your computer.

First, Right click on My Computer. (You might find this on the desktop, you might find this in your start menu. Desktop pictured)

Next, go to the Hardware tab and select “Device Manager.” (note: Windows XP is pictured, but the exact placement of device manager may vary slightly in Win98 and Vista)

Next, go to the “Ports” section of device manager and click the + sign next to it to open it, if it is not already open. You should see something like this:

Now plug in ONE of your Moates.net devices. We are going to plug them in one at a time to figure out which ports Windows is assigning to them. Assuming everything is working, you should see something like this in device manager:

The “USB Serial Port” device pictured is using COM10. Some software has issues with COM ports greater than 8, so the first thing we are going to do is change the port it uses to a port less than 8. Looking at device manager, you can see that Bluetooth Communications Port has used COM5 and a Communications Port has used COM1. We should not use either of these ports. We are going to change to COM3, which is unused. First step: right click on the “USB Serial Port” device and click “Properties.”

Next, click on the “Port Settings” tab at the top of the Window.

Next click the “Advanced” button.

On this screen, there are several things to change. First change the COM Port Number to COM3, the port we decided was open. If all of your ports say “in use” you can still select them, but it is recommended you find an unused port under 8. Second, set the Latency Timer to 1 msec. When you are done, click OK on this screen and the driver screen that follows until you are back at Device Manager.

These are the optimal settings for our devices (COM1 – COM8 and Latency = 1ms). If you had trouble, try again with these settings. Remember which port your device was using in device manager when it comes time to configure your tuning software.

Common Issues with USB Drivers and Connections

It is possible to disable devices in Windows. Sometimes this can happen accidentally. If a device is disabled, it has a red X across its icon, like the Bluetooth Communications Port in this picture.

To enable it, right click on the device and select “Enable.” Afterwards, the device should not have a red X across its icon.

Devices can also have issues loading or have device driver problems. When this happens, a yellow exclamation mark appears. Almost 100% of the time, this is a sign that you need to reinstall device drivers. If a simple reinstall does not fix the issue, there is a more heavyhanded method to reinstall drivers using FTCLEAN.

As a rule of thumb, the WHQL drivers which will be downloaded automatically will work fine.  However, it is recommended that you use the drivers from our site with Win98, WinXP and Vista.  Automatic drivers will generally work fine for Win7 but there are certain known good drivers.  We specifically recommend the latest drivers available from FTDI for machines running Windows 8, 8.1, Win10 or newer.

Specifically recommended driver versions:

• Windows 98/ME drivers can be downloaded by clicking here.
• Windows 2000/XP/Vista drivers can be downloaded by clicking here.
• There is a Vista Specific Guide that may be helpful to those running Vista.  Vista is also known to work well with the 2.08.x.x series of drivers in addition to the drivers listed above.
• Windows 7 is known to be stable with the 2.08.24 driver (available under “no longer supported drivers”) as well as the 2.12.x.x series (latest at time of writing) which are both available here.  In some cases, the 2.08 series works better than 2.12 series, your mileage may vary.  Use of drivers older than the 2.08 series is not recommended!
• 8 and 8.1 are known to be stable with the 2.08.24 driver (available under “no longer supported drivers”) as well as the 2.12.x.x series (latest at time of writing) which are both available here.  In some cases, the 2.08 series works better than 2.12 series, your mileage may vary.  Use of drivers older than the 2.08 series is not recommended!
• Windows 10 and newer machines are highly recommended to use the latest and greatest VCP drivers available directly from the USB chip’s manufacturer here. (at time of writing: 2.12.28.0)  In rare cases, the 2.08.24 driver (available under “no longer supported drivers”) can work better but this is NOT recommended.  Use of drivers older than the 2.08 series is known to cause issues!

If you have trouble, start with this troubleshooting guide.

If you have trouble, you may also want to look at FTDI’s Installation Guides for your OS.

Periodically we release new firmware for our products. We generally recommend AGAINST updating firmware unless you have a very specific reason for doing so, as there is always the chance something will go wrong during an update leaving the device bricked in a state where it has to be sent in for repair.

If you are attempting to update your firmware because you think your current firmware is corrupt, be advised that you will not be able to update your firmware unless the old firmware actually works (a little) and is able to accept new firmware. You will have to return your device to us in these cases.  Some newer r

Again, most of the time problems can be resolved without a firmware upgrade. Consult this site and/or contact us at [email protected] if you think you need a firmware update.

Firmware Update Procedure

The information on this page pertains to the following devices:

• APU1 AutoProm
• Ostrich 1.0
• Ostrich 2.0
• Flash & Burn (BURN1 / BURN2 / Jaybird)
• Roadrunner LS1 16-Bit Emulator
• QuarterHorse J3 Ford Emulator
• Demon integrated tuning device
• NEMU integrated tuning device

Directions for updating firmware:

1. Download the following utility (new version as of 2017):
   Firmware Update Utility
   and unzip it to the location of your choice.
2. Download the appropriate firmware package for your hardware from the table below and unzip it to the location of your choice (preferably to the same location as the update utility).
3. Connect your hardware to your PC and close all software applications.
4. Start the firmware update utility. Your hardware should be automatically detected. If it isn’t, click the “Detect” button
5. Click the “Browse” button in the update utility and browse to the firmware package you downloaded and unzipped in step 2 above.
6. If the package and hardware match, the “Update” button should be available. Press it now.
7. Once complete, the updater should notify you of success and display the new version information.

Firmware downloads for individual units: