Automated gas pump

One pump, seven steps.

The system is a state machine: each step has to clear before moving to the next, just like a real pump. Here’s the flow as the customer experiences it.

1. Station open? A light sensor is read. If it’s dark out, the screen shows “Closed Station” and everything is locked.
2. Card inserted. A sensor detects the card; until it’s there, the pump waits.
3. PIN. Four digits on a 4×3 keypad, masked with “*” as you type. Three wrong attempts and the card is blocked.
4. Card removed. Fueling can’t start while the card is still detected, just like at a card-operated pump.
5. Nozzle lifted. The screen prompts you to pick up the nozzle as long as it’s still holstered.
6. Fueling. As long as the trigger is held, fuel “flows”: liters and price update live on screen.
7. Receipt. Once the nozzle is holstered, the pump shows a summary (liters + amount), then “See you soon!”.

Inputs and outputs.

The fueling loop.

For every second the trigger is held, we add 2 L, recompute the price and refresh the screen. The tank caps at 45 L. Timing uses millis() instead of delay(), so the pump stays responsive while fueling.

float P_SP22 = 4.30;                 // price per liter

while (digitalRead(10) == 1) {           // nozzle in hand
  if (digitalRead(4) == 1) {           // trigger pressed
    unsigned long t0 = millis();
    while (digitalRead(4) == 1 && plein < 45) {
      if (millis() - t0 >= 1000) {
        plein += 2;                       // +2 L per second
        prix = (plein - LPT) * P_SP22;
        lcd.clear();
        lcd.print(plein);
        lcd.setCursor(10, 0);
        lcd.print(prix);
        t0 = millis();
      }
    }
  }
}

Behaving like a real pump.

• Fraud protection: after three wrong PINs, the card is flagged as blocked and rejected.
• Card must be removed before fueling, so nobody leaves it in the machine.
• No fueling without the nozzle lifted, and no receipt until it’s holstered.
• Price recomputed continuously from the volume actually dispensed.

What I learned.

• Modeling a user flow as a state machine and allowing only valid transitions.
• Securing an interface that handles money: authentication, attempt limits, lockout.
• Writing non-blocking real-time loops.
• Guiding the user with 32 characters of screen: every message counts.