Lab

State machine

STATE-MACHINE-101 Easy · Build ~15 min

The relay closed on a faulted connector

A public charging station keeps one connector’s state as three flags: plugged, charging and faulted. Events arrive from the cable (plug, unplug), the driver’s app (start, stop), the charger (a meter reading in watt-hours, a fault) and an operator (reset). Each event’s code checks the flags its author thought of.

After a fault, a driver who presses Start gets a closed relay on a connector the charger has just reported broken. A second Start while charging closes the relay again and wipes the energy counted so far, so the driver is billed for less than they took.

Reproduce

plug, start, fault, start: the second start is accepted and asks for close-relay, though the connector is faulted.

Acceptance criteria

The connector is in one phase at a time: available, plugged, charging or faulted.
Each phase allows only its own events: plug from available; unplug and start from plugged; a reading, stop and unplug from charging; a fault from every phase but faulted; reset only from faulted. Anything else is not-allowed and changes nothing.
Start closes the relay and counts energy from zero; a reading adds its watt-hours and stays charging; stop, unplug or a fault while charging opens the relay.
A fault while not charging asks the charger for nothing.

Check work runs these cases against your code once you sign in.

Not run:A faulted connector refuses start
plug, start, fault, start
Not run:A second start while charging changes nothing
plug, start, meter(500 Wh), start
Not run:A reading while not charging is refused
plug, meter(300 Wh)
Not run:A whole charge: readings add up, stop opens the relay
plug, start, meter(400 Wh), meter(250 Wh), stop, unplug
Not run:Unplugging while charging opens the relay
plug, start, meter(100 Wh), unplug
Not run:A fault while idle waits for reset
fault, plug, start, reset, plug
Not run:Reset is only for a faulted connector
plug, reset
Not run:A second plug is refused
plug, plug, unplug, unplug
Not run:Stop without a charge is refused
plug, stop, start, stop, stop
Not run:Charging again counts from zero
plug, start, meter(200 Wh), stop, start, meter(50 Wh)

Notes

Each case starts from a new connector and prints, after every event, the log line (phase and energy), the reason (accepted or not-allowed) and the effect the charger must perform (none, close-relay or open-relay).
Keep newConnector, transition and describe, with their parameters; the checker calls them and commits each decision itself. You may change the Connector type.
A faulted connector waits for an operator’s reset; the charger reports the cable again afterwards.

Hints

Reference answerTry the cases first

type Phase = 'available' | 'plugged' | 'charging' | 'faulted';
type ConnectorEvent =
  | { type: 'plug' | 'unplug' | 'start' | 'stop' | 'fault' | 'reset' }
  | { type: 'meter'; wh: number };
type Connector = { phase: Phase; energy: number };
type Decision = { connector: Connector; reason: string; effect: string };

const newConnector = (): Connector => ({ phase: 'available', energy: 0 });

// What the station's log writes after each event. The checker prints it.
const describe = (c: Connector) => `${c.phase} ${c.energy}Wh`;

// Which events each phase allows: where each leads, and what the charger must
// do (nothing, unless the rule says).
type Rule = { phase: Phase; effect?: string };
const transitions: Record<Phase, Partial<Record<ConnectorEvent['type'], Rule>>> = {
  available: {
    plug: { phase: 'plugged' },
    fault: { phase: 'faulted' },
  },
  plugged: {
    unplug: { phase: 'available' },
    start: { phase: 'charging', effect: 'close-relay' },
    fault: { phase: 'faulted' },
  },
  charging: {
    meter: { phase: 'charging' },
    stop: { phase: 'plugged', effect: 'open-relay' },
    unplug: { phase: 'available', effect: 'open-relay' },
    fault: { phase: 'faulted', effect: 'open-relay' },
  },
  faulted: {
    reset: { phase: 'available' },
  },
};

function transition(c: Connector, event: ConnectorEvent): Decision {
  const rule = transitions[c.phase][event.type];
  if (!rule) return { connector: c, reason: 'not-allowed', effect: 'none' };
  const next = { ...c, phase: rule.phase };
  if (event.type === 'start') next.energy = 0;
  if (event.type === 'meter') next.energy += event.wh;
  return { connector: next, reason: 'accepted', effect: rule.effect ?? 'none' };
}

Three flags make eight combinations, and the station has four phases; every handler that forgets one flag lets an impossible combination through, and the starter’s start forgot faulted and charging. With one phase field, the phase decides which events are legal, and one table says so for every event at once: a new event or phase is new rows, not a new check in every handler. The table also carries the effect, because what the charger must do depends on where the connector was: a fault opens the relay only from charging. A reading is a transition that stays where it is and changes the energy, which is why the table lists it under charging only: a reading while plugged is refused rather than billed.

Sign in to run your code

Read the brief and the starter here. With a free account you can edit it, run the sample, step through it and check your work, and your progress is kept.

type Phase = 'available' | 'plugged' | 'charging' | 'faulted';
type ConnectorEvent =
  | { type: 'plug' | 'unplug' | 'start' | 'stop' | 'fault' | 'reset' }
  | { type: 'meter'; wh: number };
type Connector = { plugged: boolean; charging: boolean; faulted: boolean; energy: number };
type Decision = { connector: Connector; reason: string; effect: string };

const newConnector = (): Connector =>
  ({ plugged: false, charging: false, faulted: false, energy: 0 });

// The phase the station's screen shows, worked out from the flags.
function phaseOf(c: Connector): Phase {
  if (c.faulted) return 'faulted';
  if (c.charging) return 'charging';
  return c.plugged ? 'plugged' : 'available';
}

// What the station's log writes after each event. The checker prints it.
const describe = (c: Connector) => `${phaseOf(c)} ${c.energy}Wh`;

const accept = (c: Connector, effect = 'none'): Decision =>
  ({ connector: c, reason: 'accepted', effect });
const refuse = (c: Connector): Decision =>
  ({ connector: c, reason: 'not-allowed', effect: 'none' });

// Each event sets the flags it knows about.
function transition(c: Connector, event: ConnectorEvent): Decision {
  switch (event.type) {
    case 'plug':
      return accept({ ...c, plugged: true });
    case 'unplug': {
      const effect = c.charging ? 'open-relay' : 'none';
      return accept({ ...c, plugged: false, charging: false }, effect);
    }
    case 'start':
      if (!c.plugged) return refuse(c);
      return accept({ ...c, charging: true, energy: 0 }, 'close-relay');
    case 'stop':
      if (!c.charging) return refuse(c);
      return accept({ ...c, charging: false }, 'open-relay');
    case 'meter':
      return accept({ ...c, energy: c.energy + event.wh });
    case 'fault': {
      const effect = c.charging ? 'open-relay' : 'none';
      return accept({ ...c, faulted: true, charging: false }, effect);
    }
    case 'reset':
      return accept({ ...c, faulted: false });
  }
}