A DIY car jump starter: Li-ion 3S, LiFePO4 4S and supercapacitors

draft — under discussion and being expanded

⚠ Before you start. A battery that turns a starter delivers hundreds of amps, and thousands into a short circuit. Clamps touched together weld and melt, and a damaged or overheated Li-ion cell burns in a way you cannot put out. Use insulated tools, take off rings and watches, put the fuse right at the battery, and keep the clamps covered when the pack is not in use.

How much current a starter draws

The starter is the most powerful load in a car: from 0.8 kW on a small petrol engine to 3–4.5 kW on a big diesel. But it only runs for seconds. At the first instant, while the armature is not yet turning, the current jumps to several hundred amps (the inrush); within a few tenths of a second it falls, and then it pulses with every compression stroke. A diesel needs more than a petrol engine of the same size because of its higher compression ratio.

Petrol engines, +20 °C:

Diesel engines, +20 °C:

These are typical ranges, not measurements of a particular car: they are estimated from starter power ratings in manufacturers' catalogues and checked against published measurements. For example, on 6.2 L diesels the measured inrush was 715–925 A and the cranking current 280–460 A. Your car's current depends on the starter (direct-drive or gear-reduction), the oil, the state of the engine and the battery itself. In freezing weather the oil thickens and cranking current rises 1.5–2 times; that is the last column.

Seconds, not minutes

One start takes very little energy: under 1 Wh for a warm 1.6 L petrol engine, about 3 Wh for a 2.0 L diesel including the glow plugs. A 3S 10 Ah power bank holds about 110 Wh, enough for dozens of attempts.

The hard part is not energy but current: for a few seconds the battery has to deliver 150–400 A without sagging below ~9 V, or the control units reset and the starter turns too slowly. So what matters in a jump starter is not capacity but how much current the cells can deliver. And that is why a small power bank copes: it works for seconds, not minutes.

Wait 30–60 s between attempts: a few seconds at that current noticeably heats both the starter and the cells.

Part 1. Li-ion 3S with USB-C charging

A compact unit that lives in the boot or glovebox and charges from a phone or laptop charger. Nearly all ready-made jump packs are built this way.

Why 3S and not 4S

• In voltage, a 3S pack behaves like a lead-acid battery during a start. It is 12.6 V full and sags to 9–10 V under the starter, just like lead-acid.
• A 4S Li-ion pack is too high. The car's electronics are not built to sit at 16.8 V for long, and while the clamps are connected, that is the voltage the car's wiring sits at; the alternator cannot bring it down.
• But a 3S pack must not stay connected to a running alternator. The alternator holds 14.2–14.6 V (up to 14.8 V on some cars), while a full 3S pack is 12.6 V. If the clamps stay on after the start, the alternator charges the 3S pack beyond 4.2 V per cell, which is dangerous. So the controller opens the circuit as soon as the engine is running (code below).
• LiFePO4 is a different chemistry: for 12 V the right configuration is 4S (14.4 V full, 13.2 V nominal); that is part 2.

Which cells will do

You need high-drain cells. Capacity is secondary; what matters is the continuous discharge current in the datasheet.

How many in parallel. The continuous currents of the cells in one parallel group must add up to at least your engine's cranking current. The inrush at the first instant lasts a fraction of a second and is covered by the cells' short-term output, which for high-drain cells is 1.5–2 times their continuous rating.

• 1.3–1.6 L petrol (cranking 100–170 A, inrush up to 450 A): 3S4P of Molicel P42A, 12 cells, 16.8 Ah, ≈ 180 A continuous; 2.0 L petrol (140–200 A): 3S5P;
• 2.0 L diesel (220–320 A, inrush up to 800 A): 3S8P of P42A, ≈ 360 A continuous;
• with 15–20 A 18650s, twice as many in parallel.

Cells in one parallel group must be identical, from one batch, at the same voltage before you connect them. Join them by spot-welding nickel or copper strip, not by soldering onto the can.

What "C" rating to look for

The "C" rating on a LiPo pack tells you how many times the permitted current in amps exceeds the capacity in amp-hours: 5000 mAh × 50C = 250 A. Work out what you need like this:

required C = starting current (A) ÷ capacity (Ah)

• Buy twice what the table gives. The "C" on hobby packs is often inflated; the real figure is about half of what is printed.
• Two numbers on the label (say, "50C / 100C") are the continuous and the burst (a few seconds) rating. Go by the continuous one: the burst rating on hobby packs is the most optimistic figure, and at that current the cells heat up and age faster.
• LiPo delivers noticeably less in the cold. In winter keep the pack in the warm cabin or inside your coat before a start.
• Cylindrical cells do not carry a "C" rating; the continuous current in amps is in the datasheet.

Where to get them

• New 18650 / 21700 cells from sellers of batteries for e-bikes, torches and vapes who show the cell datasheet. Check them on arrival: weight (P42A ≈ 70 g), capacity with a tester, and internal resistance (a good high-drain 21700 is up to ~15 mΩ).
• 3S LiPo packs with a high "C" rating from shops for radio-controlled models and FPV drones: high-"C" 3S and 4S packs are always on sale there.
• Avoid cells from laptop batteries and phone power banks (low current), salvaged cells with an unknown history, and "18650 9900 mAh" cells: real ones like that do not exist.

Schematic

Why the power current does not go through the BMS. There are hardly any 3S BMS boards rated for 400 A, and those that exist are large and expensive. So, as in ready-made jump packs, the BMS here sits only in the charging and balancing path, and the discharge is protected by fuse F1 and the controller: it will not close K1 if the pack is flat, and opens it if the pack sags under load.

Parts: contactor, diodes, fuse, cables

If the contactor coil has built-in electronics (an economiser, as on some LEV200 contactors), fit D1 only as the datasheet allows.

Why there is no diode in the power path. A diode would stop the alternator pushing current back into the pack, but at 300 A even a Schottky diode drops 0.5–0.6 V: that is 150–180 W of heat and half a volt lost from an already sagging 9–10 V. So the power path is switched by the contactor, and the "no backfeed" job is done by the controller: it opens K1 once the engine is running.

How the controller works

• Clamps reversed → the optocoupler signals it, K1 stays open, the red LED flashes and the buzzer warns.
• Pack flat (below 10.2 V) → K1 stays open, the red LED is on.
• A battery on the clamps, polarity right → after half a second K1 closes and the green LED lights. Now turn the key.
• The car battery is completely flat and shows no voltage on the clamps → check the polarity by eye and hold the "force" button for 3 s. ⚠ On a completely flat battery the reversed-clamp optocoupler cannot react, so in this mode only fuse F1 protects against a mistake.
• Engine running (voltage above 13.3 V for more than 2 s) → K1 opens.
• 30 s have passed, or the pack has sagged below 7.5 V for more than a second → K1 opens.
• After opening, the controller will not close K1 again until the clamps are taken off the battery. While it waits, the green LED blinks once a second; the red one is on if the circuit was opened because the pack sagged.

Controller code

The board is an Arduino Nano. Before the first use, measure the voltage on the 5V pin with a multimeter and enter it in VREF, then check the voltages the controller reads against the multimeter.

// Li-ion 3S jump starter: the controller closes contactor K1 only when it is safe,
// and opens it after the engine starts, on a timeout, or if the pack sags too far.
// Board: Arduino Nano (ATmega328P), powered with 5 V from a buck module.

const uint8_t PIN_VPACK   = A0;  // pack voltage through a 47 k / 10 k divider
const uint8_t PIN_VCLAMP  = A1;  // clamp voltage (red relative to black)
const uint8_t PIN_FORCE   = 2;   // "force" button to GND
const uint8_t PIN_REVERSE = 3;   // optocoupler output: LOW = clamps reversed
const uint8_t PIN_LED_OK  = 5;   // green: contactor closed
const uint8_t PIN_LED_ERR = 6;   // red: error or flat pack
const uint8_t PIN_K1      = 8;   // IRLZ44N gate → contactor K1 coil
const uint8_t PIN_BUZZER  = 9;   // piezo buzzer

const float DIV  = (47.0 + 10.0) / 10.0;  // divider ratio
const float VREF = 5.0;                   // measure your board's 5V rail and enter it here

const float PACK_MIN_START = 10.2;  // below this (≈ 3.4 V per cell) do not close: the pack is flat
const float PACK_MIN_LOAD  = 7.5;   // 2.5 V per cell under load for longer than LOW_MS: open
const float CLAMP_PRESENT  = 2.0;   // some battery is present on the clamps
const float CLAMP_RUNNING  = 13.3;  // above this the alternator is charging, so the engine is running

const unsigned long MAX_ON_MS     = 30000;  // contactor closed for 30 s at most
const unsigned long LOW_MS        = 1000;
const unsigned long RUN_MS        = 2000;
const unsigned long PRESENT_MS    = 500;
const unsigned long FORCE_HOLD_MS = 3000;   // hold the button 3 s to close with no battery voltage on the clamps
const unsigned long REMOVED_MS    = 2000;

enum State { IDLE, ON, WAIT_REMOVE };
State state = IDLE;
unsigned long tOn = 0, tLow = 0, tRun = 0, tForce = 0, tPresent = 0, tRemoved = 0;

float readVolts(uint8_t pin) {
  long sum = 0;
  for (uint8_t i = 0; i < 8; i++) {
    sum += analogRead(pin);
  }
  return sum / 8.0 * VREF / 1023.0 * DIV;
}

void relay(bool on) {
  digitalWrite(PIN_K1, on ? HIGH : LOW);
  digitalWrite(PIN_LED_OK, on ? HIGH : LOW);
}

// Condition timer: true once the condition has held continuously for ms.
bool heldFor(bool cond, unsigned long &since, unsigned long ms, unsigned long now) {
  if (!cond) {
    since = 0;
    return false;
  }
  if (since == 0) {
    since = now;
  }
  return now - since >= ms;
}

void turnOn(unsigned long now) {
  relay(true);
  state = ON;
  tOn = now;
  tLow = 0;
  tRun = 0;
  tone(PIN_BUZZER, 2000, 150);
}

void turnOff(bool error) {
  relay(false);
  state = WAIT_REMOVE;
  tRemoved = 0;
  digitalWrite(PIN_LED_ERR, error ? HIGH : LOW);
  tone(PIN_BUZZER, error ? 800 : 2000, error ? 800 : 300);
}

void setup() {
  pinMode(PIN_K1, OUTPUT);
  pinMode(PIN_LED_OK, OUTPUT);
  pinMode(PIN_LED_ERR, OUTPUT);
  relay(false);
  pinMode(PIN_FORCE, INPUT_PULLUP);
  pinMode(PIN_REVERSE, INPUT_PULLUP);
}

void loop() {
  unsigned long now = millis();
  float vPack  = readVolts(PIN_VPACK);
  float vClamp = readVolts(PIN_VCLAMP);
  bool reversed = digitalRead(PIN_REVERSE) == LOW;
  bool force    = digitalRead(PIN_FORCE) == LOW;

  // Reversed clamps: open in any state and wait until they are removed.
  if (reversed) {
    relay(false);
    state = WAIT_REMOVE;
    tRemoved = 0;
    digitalWrite(PIN_LED_ERR, (now / 200) % 2);
    if ((now / 200) % 10 == 0) {
      tone(PIN_BUZZER, 800, 100);
    }
    return;
  }

  switch (state) {
    case IDLE:
      digitalWrite(PIN_LED_ERR, vPack < PACK_MIN_START ? HIGH : LOW);
      if (vPack < PACK_MIN_START || vClamp > CLAMP_RUNNING) {
        tPresent = 0;
        tForce = 0;
        break;  // pack flat or engine already running: do not close
      }
      if (heldFor(vClamp > CLAMP_PRESENT, tPresent, PRESENT_MS, now)) {
        turnOn(now);  // battery on the clamps, polarity correct
      } else if (heldFor(force, tForce, FORCE_HOLD_MS, now)) {
        turnOn(now);  // battery completely flat: close on the button
      }
      break;

    case ON:
      if (now - tOn > MAX_ON_MS) {
        turnOff(false);  // time is up: the starter must not crank any longer
      } else if (heldFor(vPack < PACK_MIN_LOAD, tLow, LOW_MS, now)) {
        turnOff(true);   // the pack sagged below 2.5 V per cell
      } else if (heldFor(vClamp > CLAMP_RUNNING, tRun, RUN_MS, now)) {
        turnOff(false);  // engine running: the alternator must not charge a 3S pack to 14.4 V
      }
      break;

    case WAIT_REMOVE:
      // Do not close again until the clamps are taken off the battery.
      digitalWrite(PIN_LED_OK, (now / 1000) % 2);
      if (heldFor(vClamp < 1.0, tRemoved, REMOVED_MS, now)) {
        digitalWrite(PIN_LED_OK, LOW);
        digitalWrite(PIN_LED_ERR, LOW);
        state = IDLE;
      }
      break;
  }
}

USB-C charging

• Set the voltage with no pack connected. A module connected to the pack before the voltage is set can overcharge it within minutes.
• Because of diode D4, the pack ends the charge slightly below 12.6 V, at about 12.4–12.5 V. That is ≈ 95 % charge, and the cells last longer that way.
• Time: a 3S4P 16.8 Ah pack at 3 A takes about 6 hours.
• A slower option is a ready-made 3S charge module running from 5 V USB (10–15 W): it takes a day.
• Charge at 0–45 °C, not in a car in the sun and not unattended.

Part 2. LiFePO4 4S with a 200 A BMS: helping a flat battery

The same idea, but with LiFePO4 and without its own charger: you charge this pack with an ordinary 14.2–14.4 V LiFePO4 charger. Its job is not to start the car instead of the battery but to help a flat battery: first top it up a little, then connect directly to it for the start.

Why LiFePO4 4S fits without tricks

• LiFePO4 4S: 14.4 V full, 13.2–13.4 V at rest, 11–12.5 V under the starter. Much like a healthy lead-acid battery.
• The alternator holds 14.2–14.6 V (up to 14.8 V on some cars), which is a full charge for LiFePO4 4S or slightly above. Any overcharge from the alternator is small, and the BMS limits it: it cuts off charging at 3.65 V per cell.
• LiFePO4 tolerates overheating and damage better than Li-ion.

A 200 A BMS with a 400 A peak: is it enough?

• 200 A continuous is enough on its own to crank petrol engines up to about 2.0–2.5 L and diesels up to 1.3–1.6 L (tables above). For bigger engines the pack helps together with the lead-acid battery, connected in parallel: the current is shared between the two.
• The inrush of 450–900 A lasts tens of milliseconds, but it can trip the BMS short-circuit protection: on many boards it acts within hundreds of microseconds. The BMS then cuts its output in the middle of the start. That is exactly why the pack is connected in parallel with the car battery, not instead of it: the lead-acid battery takes the inrush, and the LiFePO4 holds the voltage up while cranking.
• Check the over-current and short-circuit thresholds and delays in the settings of a smart BMS, or the datasheet of a plain one.
• The cells must cope too. Look for the pulse current in the datasheet: for example, A123 ANR26650 cylindrical cells (2.5 Ah) give 70 A continuous and 120 A for up to 10 s, so a 4S4P pack (10 Ah) gives 280 A continuous and about 480 A as a pulse. Large 200–300 Ah prismatic cells will also do; a 4S pack of 50–100 Ah cells rated at 1C (50–100 A) will not.

How it works: pre-charge, then start

The idea of "a relay that only partly clicks and partly closes the circuit" will not work, and here is why:

Why not connect the batteries directly straight away. LiFePO4 at rest is 13.3 V, a flat lead-acid battery 11.5 V, and a completely flat one 10 V. The resistance of both batteries and the cables together is 10–20 mΩ, so 100–300 A would flow at once: at the limit of the BMS, and a charging current like that harms the lead-acid battery. Through a 0.22 Ω resistor the current is (13.3 − 11.5) / 0.22 ≈ 8 A, and up to ~15 A with a completely flat battery. The resistor dissipates 15–50 W, so use a 100 W aluminium-clad one bolted to a heatsink.

Schematic

Parts

Controller code

Put the shunt in the negative after the BMS, and wire the shunt leads to the INA226 so that discharge current from our pack reads positive. Check this with a headlight bulb before the first start.

// LiFePO4 4S jump pack + 200 A BMS: two steps.
// Step 1: pre-charge the flat car battery through a resistor (relay K2).
// Step 2: on the START button, contactor K1 connects the batteries directly while cranking.
// Current is measured by an INA226 on a 500 A / 50 mV shunt; positive means our pack is supplying.

#include <Wire.h>

const uint8_t PIN_VPACK   = A0;  // pack voltage through a 47 k / 10 k divider
const uint8_t PIN_VCLAMP  = A1;  // clamp voltage
const uint8_t PIN_START   = 2;   // START button to GND
const uint8_t PIN_REVERSE = 3;   // optocoupler: LOW = clamps reversed
const uint8_t PIN_LED_OK  = 5;
const uint8_t PIN_LED_ERR = 6;
const uint8_t PIN_K2      = 7;   // pre-charge relay (through the 0.22 ohm resistor)
const uint8_t PIN_K1      = 8;   // start contactor
const uint8_t PIN_BUZZER  = 9;

const uint8_t INA_ADDR = 0x40;     // INA226 address (module A0, A1 to GND)
const float   R_SHUNT  = 0.0001;   // 50 mV / 500 A = 0.1 milliohm
const float   DIV      = (47.0 + 10.0) / 10.0;
const float   VREF     = 5.0;      // measure your board's 5V rail

const float PACK_MIN_START = 12.9;  // ≈ 3.22 V per cell: below this the pack is nearly empty
const float PACK_MIN_LOAD  = 10.0;  // 2.5 V per cell under load
const float CLAMP_PRESENT  = 2.0;
const float CLAMP_RUNNING  = 13.6;  // before connecting: above this the engine is already running
const float I_PRE_DONE     = 3.0;   // pre-charge current fell below this: the battery has caught up
const float I_PEAK_MAX     = 380.0; // longer than I_PEAK_MS: open, the BMS is not rated for this for long
                                    // (against a short circuit its own protection is faster than ours)
const float I_LONG_MAX     = 250.0; // longer than I_LONG_MS: open as well
const float I_BACK         = -5.0;  // current flowing INTO our pack: the alternator is running
const float I_PRE_SHORT    = 40.0;  // more than this during pre-charge: the clamps are touching
const float I_PRE_NONE     = 0.3;   // less than this for a minute during pre-charge: clamps removed

const unsigned long PRE_MAX_MS   = 30UL * 60 * 1000;  // pre-charge for 15 min at most
const unsigned long CRANK_MAX_MS = 15000;             // K1 closed for 15 s at most
const unsigned long I_PEAK_MS    = 300;
const unsigned long PRE_SHORT_MS = 1000;
const unsigned long PRE_NONE_MS  = 60000;
const unsigned long I_LONG_MS    = 5000;
const unsigned long RUN_MS       = 2000;
const unsigned long LOW_MS       = 1000;
const unsigned long PRESENT_MS   = 500;
const unsigned long REMOVED_MS   = 2000;

enum State { IDLE, PRECHARGE, CRANK, WAIT_REMOVE };
State state = IDLE;
unsigned long tState = 0, tPresent = 0, tPeak = 0, tLong = 0, tRun = 0, tLow = 0, tDone = 0, tRemoved = 0;
unsigned long tShort = 0, tNone = 0;
bool lastStart = false;

float readVolts(uint8_t pin) {
  long sum = 0;
  for (uint8_t i = 0; i < 8; i++) {
    sum += analogRead(pin);
  }
  return sum / 8.0 * VREF / 1023.0 * DIV;
}

// INA226 register 0x01: signed shunt voltage, 2.5 uV per bit.
float readAmps() {
  Wire.beginTransmission(INA_ADDR);
  Wire.write(0x01);
  if (Wire.endTransmission() != 0) {
    return NAN;
  }
  if (Wire.requestFrom(INA_ADDR, (uint8_t) 2) != 2) {
    return NAN;
  }
  uint8_t hi = Wire.read();  // two separate reads: the order inside one expression is not guaranteed
  uint8_t lo = Wire.read();
  int16_t raw = (int16_t) ((hi << 8) | lo);
  return raw * 2.5e-6 / R_SHUNT;
}

bool heldFor(bool cond, unsigned long &since, unsigned long ms, unsigned long now) {
  if (!cond) {
    since = 0;
    return false;
  }
  if (since == 0) {
    since = now;
  }
  return now - since >= ms;
}

void setRelays(bool k2, bool k1) {
  digitalWrite(PIN_K2, k2 ? HIGH : LOW);
  digitalWrite(PIN_K1, k1 ? HIGH : LOW);
}

void go(State s, unsigned long now) {
  state = s;
  tState = now;
  tPeak = tLong = tRun = tLow = tDone = tRemoved = tShort = tNone = 0;
}

void stopAll(bool error, unsigned long now) {
  setRelays(false, false);
  digitalWrite(PIN_LED_ERR, error ? HIGH : LOW);
  tone(PIN_BUZZER, error ? 800 : 2000, error ? 800 : 300);
  go(WAIT_REMOVE, now);
}

void setup() {
  pinMode(PIN_K1, OUTPUT);
  pinMode(PIN_K2, OUTPUT);
  setRelays(false, false);
  pinMode(PIN_LED_OK, OUTPUT);
  pinMode(PIN_LED_ERR, OUTPUT);
  pinMode(PIN_START, INPUT_PULLUP);
  pinMode(PIN_REVERSE, INPUT_PULLUP);
  Wire.begin();
}

void loop() {
  unsigned long now = millis();
  float vPack  = readVolts(PIN_VPACK);
  float vClamp = readVolts(PIN_VCLAMP);
  float amps   = readAmps();
  bool reversed = digitalRead(PIN_REVERSE) == LOW;

  // INA226 not responding: without a current reading there is no protection and no start detection, so open everything.
  if (isnan(amps)) {
    setRelays(false, false);
    if (state != WAIT_REMOVE) {
      go(WAIT_REMOVE, now);
    }
    digitalWrite(PIN_LED_ERR, (now / 500) % 2);
    return;
  }
  bool startNow = digitalRead(PIN_START) == LOW;
  bool startPressed = startNow && !lastStart;  // only the moment of pressing
  lastStart = startNow;

  if (reversed) {
    setRelays(false, false);
    if (state != WAIT_REMOVE) {
      go(WAIT_REMOVE, now);
    }
    digitalWrite(PIN_LED_ERR, (now / 200) % 2);
    return;
  }

  switch (state) {
    case IDLE:
      digitalWrite(PIN_LED_ERR, vPack < PACK_MIN_START ? HIGH : LOW);
      if (vPack >= PACK_MIN_START && vClamp < CLAMP_RUNNING
          && heldFor(vClamp > CLAMP_PRESENT, tPresent, PRESENT_MS, now)) {
        setRelays(true, false);  // step 1: pre-charge through the resistor
        tone(PIN_BUZZER, 2000, 150);
        go(PRECHARGE, now);
      }
      break;

    case PRECHARGE:
      // Blinking: pre-charging; steady: the current has dropped, ready to start.
      if (heldFor(amps < I_PRE_DONE, tDone, 5000, now)) {
        digitalWrite(PIN_LED_OK, HIGH);
      } else {
        digitalWrite(PIN_LED_OK, (now / 500) % 2);
      }
      if (startPressed) {
        setRelays(false, true);  // step 2: direct connection while cranking
        tone(PIN_BUZZER, 2500, 200);
        go(CRANK, now);
      } else if (heldFor(amps > I_PRE_SHORT, tShort, PRE_SHORT_MS, now)) {
        stopAll(true, now);   // clamps touching: too much current through the resistor
      } else if (heldFor(amps < I_PRE_NONE, tNone, PRE_NONE_MS, now)) {
        stopAll(false, now);  // clamps removed: do not keep them live
      } else if (now - tState > PRE_MAX_MS || vPack < PACK_MIN_START - 0.4) {
        stopAll(false, now);
      }
      break;

    case CRANK:
      digitalWrite(PIN_LED_OK, HIGH);
      if (now - tState > CRANK_MAX_MS) {
        setRelays(true, false);  // did not start: back to pre-charge, another attempt is allowed
        go(PRECHARGE, now);
      } else if (heldFor(amps > I_PEAK_MAX, tPeak, I_PEAK_MS, now)
                 || heldFor(amps > I_LONG_MAX, tLong, I_LONG_MS, now)) {
        stopAll(true, now);   // current too high for too long
      } else if (heldFor(vPack < PACK_MIN_LOAD, tLow, LOW_MS, now)) {
        stopAll(true, now);   // the pack sagged
      } else if (heldFor(amps < I_BACK, tRun, RUN_MS, now)) {
        stopAll(false, now);  // the alternator is charging us: the engine is running
      }
      break;

    case WAIT_REMOVE:
      digitalWrite(PIN_LED_OK, (now / 1000) % 2);
      if (heldFor(vClamp < 1.0, tRemoved, REMOVED_MS, now)) {
        digitalWrite(PIN_LED_OK, LOW);
        digitalWrite(PIN_LED_ERR, LOW);
        go(IDLE, now);
      }
      break;
  }
}

How to use it:

1. Clamps on the battery: red to "+", black to "−". The green LED flashes: pre-charging.
2. Wait 5–15 min. When the green LED is steady, the pre-charge current has dropped below 3 A.
3. Press START and turn the key within 15 s. Crank for no more than 5–10 s.
4. The engine is running: the controller opens the circuit by itself. Not running: after 15 s the controller returns to pre-charging; wait 30–60 s and repeat from step 3.

If the clamps touch during the pre-charge, the current through the resistor exceeds 40 A and the controller opens the circuit within a second. If the clamps are taken off, the current drops to zero and within a minute the controller opens K2 as well. The pre-charge lasts 30 min at most.
5. Take the clamps off: black first\, then red.

Can a car be started with no lead-acid battery at all?

In short: you can turn the starter, but you cannot drive like that.

So a jump pack helps a battery for a few seconds, or gives an emergency start to get you to a battery replacement. It does not replace the battery.

Li-ion or LiFePO4

Verdict: for a unit that rides in the car all the time or is connected in parallel with the battery, LiFePO4 4S is better. For a compact pack in the glovebox that charges from USB-C and goes with you, Li-ion or LiPo 3S, but only with a controller that disconnects after the start, and not in the sun in summer.

Supercapacitors

Supercapacitors store little energy but deliver enormous current: the internal resistance of a module is a few milliohms. Cold hardly bothers them (they work down to −40 °C), and they last hundreds of thousands of cycles. The downside is fast self-discharge, over days or weeks, so you charge them just before the start.

What to build it from: six 2.7 V 3000 F cells in series (16.2 V, 500 F in total) with balancing boards, or a ready-made 16 V 500 F module (for example, Maxwell BMOD0500 P016).

Is there enough energy? A capacitor holds ½·C·U². Going from 15 to 9 V, a 500 F module delivers ½ × 500 × (15² − 9²) = 36 kJ ≈ 10 Wh, while a start takes 0.7–3 Wh. Plenty. But a bank of six 500 F cells (83 F in total) gives only ≈ 1.7 Wh, enough for one start of a warm petrol engine.

How to charge supercapacitors

• Never above 2.7 V per cell (16.2 V for six), and only with balancing boards: without them one cell charges higher than the others and fails.
• A module charged to 11 V from a weak battery delivers only ½ × 500 × (11² − 9²) = 10 kJ ≈ 2.8 Wh down to 9 V, nearly four times less than one charged to 15 V. That is often enough for a warm engine, but it is why ready-made supercapacitor jump starters have a boost converter: it charges the module above the battery voltage.
• Connect the charged module just before you turn the key. Otherwise within minutes it discharges into the flat lead-acid battery, and the energy goes there instead of to the starter.
• A charged module delivers hundreds of amps into a short circuit, so keep the terminals covered. Discharge it through a resistor for storage.

Testing and safety

• Test it first without a car. Connect a headlight bulb (55–60 W) to the clamps and make sure K1 closes and that the voltages and current the controller reads match a multimeter.
• Test the reversed-clamp protection on a healthy battery with the K1 coil disconnected: the red LED should flash and the green one should stay off (it shows the command to close K1).
• Crank for no more than 5–10 s, with 30–60 s between attempts.
• Red clamp to "+", black to "−" on the battery or to engine ground. Never touch the clamps together.
• Do not leave Li-ion in a car in the summer sun or charge it unattended. Do not charge either Li-ion or LiFePO4 below 0 °C.
• If a cell has swollen, gets warm with no load, or smells, take it out of service.

[TO ADD: what we have built from this, photos, current measurements on our car]

Article changelog

• 2026-11-10 — first draft: starter current by engine size (tables, charts), a Li-ion 3S jump pack with USB-C charging, a LiFePO4 4S pack with a 200 A BMS and pre-charge, starting without a lead-acid battery, Li-ion or LiFePO4, supercapacitors.