Before a Speeduino ECU is allowed to control a real engine, TunerStudio should be used to prove that the ECU is configured correctly, the sensors make sense, the trigger pattern is stable and every output goes to the channel you think it does. That is commissioning, not tuning.
A surprisingly large number of “bad tune” problems are actually setup faults: the wrong firmware definition, a TPS that was never calibrated, coolant and air temperature sensors using the wrong curve, injector outputs mapped to the wrong cylinders, or a crank decoder that appears to show RPM but loses sync.
This guide focuses on the TunerStudio and bench-check stage: loading firmware, creating the project, matching the correct speeduino.ini, verifying communications, calibrating inputs, testing outputs safely and proving crank/cam decoding before the first real start.
What You Need Before Opening TunerStudio
- A Speeduino-compatible ECU or official/third-party hardware with known documentation.
- The correct Speeduino firmware for that board/processor.
- The matching TunerStudio
speeduino.ini. - TunerStudio installed on Windows, macOS or Linux.
- A USB/serial connection that is known to work.
- A regulated bench supply or the vehicle electrical system with proper fusing.
- A multimeter.
- Preferably test LEDs, lamps or suitable dummy loads for output checks.
- Optionally Ardu-Stim for simulated crank/cam patterns.
Do not begin bench testing with injectors spraying fuel or ignition coils producing high voltage. Prove the ECU logic first with safe indicators or dummy loads wherever practical.
If you are new to the platform, read our Speeduino Explained: How the DIY Arduino ECU Works first. For harness and sensor wiring, use the separate Speeduino Wiring Guide.
Firmware and INI Must Match
This is the first rule of TunerStudio setup. The Speeduino firmware running in the ECU and the speeduino.ini used by the TunerStudio project must describe the same firmware generation.
The INI tells TunerStudio:
- What settings exist.
- How configuration pages are laid out.
- Which tables and gauges are available.
- How values are scaled.
- Which serial commands the ECU understands.
- Which calibration and test menus TunerStudio should display.
If the firmware and INI do not match, TunerStudio may warn about a signature mismatch. Do not ignore that warning and continue changing settings. At best, fields or menus may be wrong; at worst, values can be written to locations that mean something different to the firmware.
As of September 2026, the Speeduino GitHub release page identifies 202501.7 as the latest stable firmware release. The live master branch can contain development changes beyond the latest release, including a newer INI signature. Use the INI supplied for the actual firmware version running in your ECU rather than copying the newest file from master by default.
Use SpeedyLoader When Possible
SpeedyLoader is the official universal firmware loader for Speeduino. It lets you choose a firmware release, select the ECU/serial port and upload a precompiled build without manually compiling the Arduino source.
Current SpeedyLoader also supports downloading base tunes matched to the selected firmware version. That is useful because it reduces the chance of starting with an old tune whose firmware signature or available features no longer match the ECU.
The basic sequence is:
- Select the Speeduino firmware version.
- Confirm the correct ECU board/processor target.
- Select the correct serial/USB port.
- Upload the firmware.
- Use the matching INI/base tune when creating the TunerStudio project.
If you deliberately build firmware from the current development branch, use the matching INI from that same code revision and accept that you are no longer on the normal stable-release path.
Create the TunerStudio Project
Create a new TunerStudio project and select the Speeduino ECU definition. If TunerStudio asks for the ECU definition file manually, point it to the matching speeduino.ini.
Connect the ECU by USB or the supported communications interface and let TunerStudio identify the firmware signature. The project should open without an ECU-definition mismatch.
At this point do not immediately import somebody else’s tune and start changing fuel tables. First confirm that TunerStudio and the ECU agree on the basic hardware and engine configuration.
If TunerStudio Will Not Connect
| Symptom | First checks |
|---|---|
| No serial port | USB cable, board power, USB driver and operating-system device manager |
| Port exists but TunerStudio cannot connect | Correct COM/tty port, another application holding the port, firmware actually running |
| Connects then drops | Power stability, USB cable quality, ground problems and firmware/communications issues |
| Signature mismatch | Wrong speeduino.ini for the firmware |
| Project opens with missing or strange menus | INI mismatch or unsupported board/firmware combination |
| Works on USB power but behaves differently on vehicle power | Check ECU supply voltage, grounds and board power-path behaviour |
Recent Speeduino releases have included several communications fixes, so if you are troubleshooting an old installation, first establish exactly which firmware is loaded before assuming the hardware is faulty.
Save a Known Baseline Before Changing Anything
Once communication works, save the current tune/project as a baseline. Give the file a useful name that includes the firmware and date.
Bandit400_Speeduino_202501.7_BenchBaseline_2026-09-14.msqThat gives you a known return point if later calibration or setup work goes wrong. Save another copy after each major milestone: sensors calibrated, trigger confirmed, outputs confirmed, first crank and first stable idle.
Set the Basic Engine Configuration First
Before bench testing outputs, TunerStudio needs a configuration that describes the engine and available hardware correctly. The exact menu names vary slightly with firmware release and board type, but the fundamentals are:
- Number of cylinders.
- Engine cycle / stroke type.
- Injection mode: batch, semi-sequential or sequential as supported.
- Ignition mode: distributor, wasted spark, coil-on-plug or other supported strategy.
- Injector count and channel arrangement.
- Trigger pattern and tooth count.
- Secondary/cam input requirement.
- Board pin mapping/layout.
If you do not know these values, stop and identify the engine and hardware. TunerStudio cannot infer the crank wheel, injector size or ignition architecture from the USB cable.
Bench Check the ECU Power First
Before connecting sensors or output loads, power the ECU from a properly fused, current-limited supply suitable for the board. Verify:
- No component becomes abnormally hot.
- The expected 5 V and/or 3.3 V rails are correct.
- TunerStudio remains connected.
- The battery-voltage channel shows a plausible value.
- The ECU does not reset when relay outputs are switched.
If battery voltage in TunerStudio differs significantly from a trusted meter measured at the ECU supply, fix or calibrate that before tuning. Speeduino uses battery voltage for corrections such as injector dead-time behaviour and ignition charging strategy.
Check Sensor Readings with the Engine Stopped
With the engine cold and not running, TunerStudio should already tell you a lot about whether the installation is sane.
| Sensor | What should make sense before cranking |
|---|---|
| CLT | Close to actual coolant/ambient temperature on a cold engine |
| IAT | Close to ambient air temperature |
| MAP | Close to local atmospheric pressure with engine stopped |
| TPS | Near 0% closed and near 100% open after calibration |
| Battery | Close to the voltage measured at the ECU |
| O₂ / AFR | Matches the external wideband controller or known calibration behaviour |
| RPM | 0 when no trigger signal is present |
A MAP sensor reading 40 kPa on the bench with its pressure port open to atmosphere is not a fuel-table problem. A coolant sensor showing -40°C in a warm workshop is not a cold-start tuning problem. Fix the input first.
Calibrate TPS Before Anything Else Uses It
A conventional TPS is a potentiometer. TunerStudio needs to learn the voltage/ADC value corresponding to closed throttle and wide-open throttle.
Use the Speeduino TPS calibration function defined by the matching INI:
- Leave the throttle fully closed.
- Capture the closed-throttle value.
- Open the throttle fully by hand.
- Capture the wide-open value.
- Save/burn the calibration.
- Move the throttle slowly from closed to open and confirm the reading is smooth.
If TPS jumps, drops out or moves in the wrong direction, investigate the sensor wiring and ground reference before configuring acceleration enrichment.
Calibrate CLT and IAT to the Actual Sensors
Coolant and inlet-air sensors are commonly NTC thermistors. The ECU converts their resistance/ADC value into temperature using the configured calibration curve.
If you are using a known sensor with an existing calibration, select the correct curve. For an unknown sensor, obtain resistance-versus-temperature data or measure it properly and create the calibration from real values.
On a cold engine that has been sitting for hours, CLT and IAT should usually be reasonably close to each other and to ambient conditions. A large discrepancy is an immediate clue that one calibration or wiring path is wrong.
Check MAP at Key-On, Engine-Off
With the engine stopped and the MAP sensor exposed to manifold pressure equal to atmosphere, MAP should read close to the local barometric pressure.
Do not expect one universal number because atmospheric pressure varies with weather and altitude. The important check is plausibility. If a nearby weather station or trusted barometer says around 100 kPa and Speeduino shows 62 kPa, investigate calibration, wiring or the selected sensor type.
Check the Wideband/Oxygen Input
If you use an external wideband controller, first make sure the controller works independently. Then compare its own display/output with the AFR or lambda value in TunerStudio.
If they disagree, common causes are:
- Wrong 0–5 V wideband calibration selected.
- Wideband analogue ground and ECU sensor ground differ.
- Controller output has been programmed for a different voltage/lambda curve.
- AFR and lambda are being compared using different stoichiometric fuel values.
Do not start autotune or closed-loop correction until the ECU’s AFR value agrees with the controller you are trusting.
Output Test Mode: Use It Before the Engine
Speeduino’s TunerStudio definition includes hardware output-test controls. They are extremely useful for proving channel mapping before cranking, but the warning in the interface is there for a reason: output testing can energise real hardware.
For the first test, disconnect fuel and high-energy ignition loads where possible and use a safe test lamp, LED circuit, oscilloscope or suitable dummy load.
Use output testing to verify:
- Fuel-pump relay output.
- Injector channels.
- Ignition output channels.
- Cooling-fan output.
- Idle valve outputs where applicable.
- Boost/VVT/auxiliary outputs where applicable.
The goal is not merely “the output toggles.” Confirm that the output labelled INJ1 actually reaches injector channel 1 in the harness, and similarly for every ignition channel.
Do Not Bench-Fire Ignition Coils Casually
An ignition output is not a harmless LED output. A coil can generate tens of kilovolts, and the primary current can overheat the coil or driver if dwell or polarity is wrong.
Before connecting real coils:
- Confirm whether the coil is logic-level or requires an external igniter.
- Confirm the Speeduino board’s ignition-output type.
- Confirm output polarity.
- Confirm dwell configuration is appropriate for the coil/igniter.
- Keep HT outputs safely terminated if live spark testing is performed.
If a coil or igniter becomes hot with the engine stopped, disconnect power immediately and re-check the output architecture and polarity.
Injector Output Checks
For the first bench test, a suitable electrical test load is preferable to a fuel injector connected to a pressurised fuel rail.
Verify:
- Each injector channel switches independently.
- The harness connector labels match the configured firing/channel order.
- The ECU low-side driver is wired as intended.
- No injector output is permanently active.
- Supply voltage remains stable during output testing.
When real injectors are eventually connected, perform any live bench pulsing with the fuel system depressurised or arranged safely. Fuel spray and ignition testing should never share the same casual bench setup.
Use Ardu-Stim to Prove the Trigger Decoder
Ardu-Stim is one of the best tools in the Speeduino ecosystem because it generates simulated crank, cam and tertiary trigger signals without rotating a real engine.
The official Speeduino Ardu-Stim fork supports a large set of trigger patterns and can vary simulated RPM. On an Arduino Nano/Uno, its documented default outputs are:
| Ardu-Stim signal | Nano / Uno pin |
|---|---|
| Primary crank | D8 |
| Secondary cam | D9 |
| Tertiary / second cam | D10 |
Connect the simulator through the correct Speeduino input conditioning path for your board. Ardu-Stim gives digital trigger signals; do not assume that connecting it to a VR conditioner input exactly reproduces the analogue behaviour of a real VR sensor.
What to Check with Simulated RPM
- TunerStudio shows the expected RPM.
- RPM is stable rather than jumping randomly.
- Sync is achieved with the selected decoder.
- Sync remains stable as RPM increases.
- Cam/secondary synchronisation behaves correctly if required.
- Injector and ignition events occur in the expected sequence.
A simulated trigger is not proof that the real crank sensor installation will work under starter noise, weak VR voltage or ignition interference. It is proof that the basic decoder configuration and ECU-side signal path can work.
Use the Tooth / Trigger Logging Tools
Do not judge a crank signal only from the RPM gauge. Speeduino firmware explicitly supports high-speed tooth/trigger logging, and TunerStudio can display the captured trigger timing.
For a missing-tooth wheel, the logger should show a repeatable longer gap corresponding to the missing tooth region. Extra spikes, missing pulses or inconsistent timing are clues that the decoder selection, trigger edge or electrical signal is wrong.
When testing on the actual engine, capture logs during cranking before fuel and ignition are enabled. Stable cranking RPM and a clean tooth pattern should come before any attempt to tune VE or ignition tables.
RPM but No Sync Is Still a Trigger Problem
An ECU can sometimes calculate an apparent RPM from crank transitions while still failing to establish reliable engine position.
If TunerStudio shows RPM but sync is unstable, investigate:
- Wrong decoder or tooth count.
- Wrong rising/falling trigger edge.
- VR sensor polarity.
- VR conditioner threshold/hysteresis.
- Hall pull-up or logic voltage.
- Missing/incorrect cam phase.
- Noise from starter, coils or injectors.
- Poor grounds or shield termination.
Fix the trigger system before tuning. A fuel table cannot compensate for the ECU losing track of crank angle.
Do a Sensor Disturbance Test
On the bench or vehicle, deliberately operate high-current outputs while watching the analogue sensors in TunerStudio.
Examples:
- Switch the fuel-pump relay.
- Operate the cooling-fan relay.
- Toggle test loads on injector/aux channels.
TPS, MAP, CLT and IAT should not jump simply because a relay switched. If analogue readings move with high-current loads, investigate power distribution, sensor grounds and harness routing before hiding the problem with software filtering.
Check Fuel-Pump Behaviour
The fuel-pump output is easy to overlook because it appears simple. Confirm that the intended relay output primes when expected and turns off when the ECU no longer sees a running engine.
On the bench use the relay or a safe simulated load first. On the vehicle, confirm the pump circuit is fused and that a stalled engine does not leave the pump running indefinitely because of wiring around the ECU control.
Base Tune Does Not Mean Safe Tune
A base tune is useful because it gives you a structured configuration rather than a blank project. It is not proof that the fuel and ignition tables are safe for your engine.
Before using a downloaded base tune, compare at least:
- Cylinder count.
- Engine displacement.
- Injector flow rate.
- Injector dead-time data.
- Fuel pressure.
- Trigger pattern.
- Ignition hardware and dwell requirements.
- MAP sensor range.
- Temperature sensor calibrations.
- Wideband calibration.
If those fundamentals differ, copying the VE and ignition tables is not a shortcut to a working engine.
Before the First Real Crank
By the time the starter motor is first used, the following should already be true:
- TunerStudio connects reliably.
- Firmware and INI match.
- Board/pin mapping is correct.
- TPS is calibrated and smooth.
- CLT and IAT are plausible.
- MAP is plausible at atmospheric pressure.
- Battery voltage is believable.
- Wideband input calibration is known.
- Fuel-pump output is verified.
- Injector channels are mapped correctly.
- Ignition channels and polarity are confirmed.
- Trigger decoder settings match the engine.
- No unexpected output remains permanently active.
First Crank: Disable Fuel or Spark While Proving Trigger Timing
The first starter-motor test should be a diagnostic exercise. Crank the engine with fuel and/or ignition disabled as appropriate for the checks you are performing, then observe RPM, sync and trigger logs.
Once crank synchronisation is proven, the ignition reference should be checked physically with a timing light before load tuning. The ECU’s displayed advance is only useful if its configured crank reference matches the engine’s real crankshaft position.
If commanded fixed timing and measured timing do not agree, correct the trigger angle/reference setup first. Do not “repair” a mechanical reference error by reshaping the ignition table.
What TunerStudio Should Look Like Before First Start
| Channel | Expected condition |
|---|---|
| RPM | 0 stopped; stable and plausible while cranking |
| Sync | Stable after decoder establishes position |
| TPS | 0–100% smoothly |
| MAP | Atmospheric stopped; responds to manifold pressure/vacuum |
| CLT | Plausible actual temperature |
| IAT | Plausible actual temperature |
| Battery | Close to meter; drops plausibly while cranking |
| AFR/lambda | Matches wideband behaviour when controller is ready |
| Injector PW | No impossible or stuck-on output state |
| Ignition advance | Plausible commanded value, then physically verified |
Common TunerStudio Setup Problems
| Problem | Likely cause | What to do |
|---|---|---|
| Strange menus or values | Firmware/INI mismatch | Use the matching Speeduino INI |
| TPS never reaches 0/100% | Not calibrated or wiring issue | Run TPS calibration and verify sensor ground |
| CLT reads -40°C | Open circuit/wrong calibration | Check wiring and thermistor curve |
| MAP wrong with engine stopped | Wrong sensor calibration/wiring | Verify sensor type and pressure reference |
| RPM jumps wildly | Trigger noise or decoder problem | Inspect tooth log and input conditioning |
| RPM exists but sync drops | Trigger/cam phase problem | Check decoder, edge, polarity and cam input |
| Injector 1 test drives wrong cylinder | Harness/channel mapping error | Correct wiring or configuration before cranking |
| Coil gets hot with engine off | Ignition polarity/dwell/output error | Power down immediately and verify hardware |
| Sensors jump when relay switches | Ground/power noise | Fix wiring before adding filters |
| Wideband display and TS disagree | Wrong analogue calibration/ground offset | Match controller voltage curve and grounds |
A Good Bench-Test Order
- Power the ECU alone and verify rails/current.
- Flash the intended stable firmware.
- Create a TunerStudio project with the matching INI.
- Save a baseline tune.
- Configure engine/board basics.
- Calibrate TPS, CLT, IAT, MAP and wideband inputs.
- Check battery-voltage accuracy.
- Test relays and low-risk outputs.
- Verify injector/ignition channel mapping with safe test methods.
- Use Ardu-Stim or another simulator to check trigger decoding.
- Capture trigger/tooth logs.
- Crank the real engine with fuel/spark disabled as required.
- Verify real ignition reference with a timing light.
- Only then proceed toward first start and tuning.
Following that order turns first start into a controlled commissioning step instead of a lottery.
Related Speeduino Guides
- Speeduino Explained: How the DIY Arduino ECU Works — architecture, fuel, ignition, sensors and TunerStudio overview.
- Speeduino Wiring Guide — crank/cam, sensors, injectors, ignition and grounds.
- Speeduino vs rusEFI vs MegaSquirt — choosing a DIY/open-source ECU platform.
Official Speeduino Resources
- Speeduino firmware releases — stable firmware downloads and release notes.
- Speeduino master INI — current development TunerStudio definition; use only with matching firmware.
- SpeedyLoader — official cross-platform firmware loader.
- Speeduino Ardu-Stim — crank/cam trigger simulator for bench testing.
- Official Speeduino Hardware Repository — board and conditioner designs.