Self-Serve Dog Fetch Launcher v2

The problem

Most automatic ball launchers are built for yards, not living rooms. They throw 30 feet or more, and the dog has no safe way to trigger them. I wanted something that fits in a living room, is operated entirely by the dog, and gives her time to get out of the way before the ball leaves the machine. This revision features a drop in hopper vs the initial design that was essentially a large pvc pipe with a funnel at one end and flywheels on the other.

How it works

The ball takes a short, simple path. It drops into the hopper and rests on a servo-driven gate, where an infrared beam detects it. That starts a three second countdown. Just before the gate opens, two counter-rotating wheels spin up to the speed set by the dial. The ball rolls down a short ramp into the gap between the wheels, which pinch it and throw it out of the front of the enclosure.

Control logic

The firmware is a four-state machine with no blocking delays, so the sensor and timers always stay responsive.

Why dual flywheels

The physics, and the 15 ft cap

A flywheel launcher throws the ball at roughly the speed of the wheel rim. That makes the sizing a short calculation. These are ideal numbers that ignore air drag, wheel slip and the small height of the exit above the floor, so they are a starting point for calibration, not a spec.

Enclosure and mock-ups

The enclosure has three jobs: guide the ball, keep paws and noses away from the wheels, and stay put when it fires. The wheels sit in a closed box whose only openings are the ball-sized entry from the hopper and the ball-sized exit slot at the front.

1. Funnel hopper. A 3.5 in inside diameter tube with a flared lip. Wide enough for a tennis ball, too narrow for a snout to reach anything.
2. Ball at rest on the gate. The IR break-beam crosses the tube at mid-ball height, so only a ball resting on the gate can trip it.
3. Servo gate. A small SG90 servo swings a flap that holds the ball until the 3 second timer ends.
4. Feed ramp. A short ramp, about 20 to 25 degrees, rolls the released ball into the wheel gap.
5. Counter-rotating wheels. The gap is set slightly smaller than the ball so both wheels grip and compress it.
6. Exit chute. Fixed at a shallow 15 to 20 degree upward angle so even a full-power throw stays well below the ceiling.
7. Electronics bay. Behind a removable panel, away from the ball path.

All angles and gaps are starting values to tune on the bench. Wheel grip on the ball and the ramp slope are the two things most likely to need adjustment.

Materials. Quarter-inch plywood is easy to cut and stiff enough. 3D-printed PETG panels are a good alternative because wheel spacing can be tuned between prints. The base is wide and weighted, with non-slip feet, so the launcher does not walk across the floor when it fires.

Electronics

An Arduino Uno handles everything. A microcontroller with no operating system is a better fit than a single-board Linux computer here, because PWM, servo timing and sensor debouncing all need predictable timing.

Parts and cost

Spare motors, scrap plywood or a 3D printer bring that down. Plan on roughly 8 to 15 hours for the whole build, with wheel spacing and range calibration taking the most trial and error.

Firmware

The sketch below runs the state machine. MIN_LAUNCH_PWM and MAX_LAUNCH_PWM are deliberately conservative starting values. Raise the maximum in small steps during testing until a throw lands at 15 ft, then leave it there.

#include <Servo.h>

// Pin definitions
const int IR_SENSOR_PIN  = 2;   // break-beam receiver, LOW = beam broken (ball waiting at gate)
const int BUZZER_PIN     = 4;
const int MOTOR_A_PWM    = 5;   // driver enable A (PWM)
const int MOTOR_B_PWM    = 6;   // driver enable B (PWM)
const int MOTOR_A_IN1    = 7;
const int MOTOR_A_IN2    = 8;
const int SERVO_GATE_PIN = 9;
const int MOTOR_B_IN1    = 10;
const int MOTOR_B_IN2    = 11;
const int SPEED_POT_PIN  = A0;

Servo gateServo;

// Gate positions in degrees, tune to your mechanism
const int GATE_CLOSED = 0;
const int GATE_OPEN   = 90;

// Timing in milliseconds
const unsigned long COUNTDOWN_MS     = 3000;  // delay before the ball is released
const unsigned long SPINUP_LEAD_MS   = 800;   // wheels start this long before release
const unsigned long FIRE_DURATION_MS = 800;   // gate stays open while the ball drops and launches
const unsigned long RESET_DELAY_MS   = 1000;  // pause before accepting another ball
const unsigned long BEAM_DEBOUNCE_MS = 100;   // beam must stay broken this long to count

// Speed limits, PWM 0 to 255
// Conservative starting values. Calibrate with a tape measure:
// raise MAX_LAUNCH_PWM in small steps until the first landing point is 15 ft,
// then stop. The dial can never exceed this cap.
const int MIN_LAUNCH_PWM = 50;    // calibrate so the dial minimum lands about 3 ft out
const int MAX_LAUNCH_PWM = 150;   // calibrate so the dial maximum lands about 15 ft out
const int IDLE_PWM       = 0;

enum State { IDLE, COUNTDOWN, FIRE, RESET_STATE };
State currentState = IDLE;

unsigned long stateStartTime = 0;
unsigned long beamSince = 0;
int lastBeepSecond = -1;
int launchSpeed = MIN_LAUNCH_PWM;

void setup() {
  pinMode(IR_SENSOR_PIN, INPUT_PULLUP);
  pinMode(MOTOR_A_IN1, OUTPUT);
  pinMode(MOTOR_A_IN2, OUTPUT);
  pinMode(MOTOR_B_IN1, OUTPUT);
  pinMode(MOTOR_B_IN2, OUTPUT);
  pinMode(BUZZER_PIN, OUTPUT);

  // The two wheels counter-rotate so both rims push the ball forward.
  // If the ball is driven backward, swap the wires on one motor.
  digitalWrite(MOTOR_A_IN1, HIGH);
  digitalWrite(MOTOR_A_IN2, LOW);
  digitalWrite(MOTOR_B_IN1, LOW);
  digitalWrite(MOTOR_B_IN2, HIGH);

  gateServo.attach(SERVO_GATE_PIN);
  gateServo.write(GATE_CLOSED);

  setMotorSpeed(IDLE_PWM);

  Serial.begin(9600);
  Serial.println("Ball launcher ready.");
}

void loop() {
  switch (currentState) {

    case IDLE:
      if (digitalRead(IR_SENSOR_PIN) == LOW) {
        if (beamSince == 0) beamSince = millis();
        if (millis() - beamSince >= BEAM_DEBOUNCE_MS) {
          launchSpeed = readSpeedDial();
          stateStartTime = millis();
          lastBeepSecond = -1;
          beamSince = 0;
          currentState = COUNTDOWN;
          Serial.print("Ball detected. Launch PWM: ");
          Serial.println(launchSpeed);
        }
      } else {
        beamSince = 0;
      }
      break;

    case COUNTDOWN: {
      unsigned long elapsed = millis() - stateStartTime;

      // One beep per second at 0 s, 1 s and 2 s
      int secondMark = elapsed / 1000;
      if (secondMark != lastBeepSecond && secondMark < 3) {
        lastBeepSecond = secondMark;
        tone(BUZZER_PIN, 1000, 150);
      }

      // Spin the wheels up just before the gate opens
      if (elapsed >= COUNTDOWN_MS - SPINUP_LEAD_MS) {
        setMotorSpeed(launchSpeed);
      }

      if (elapsed >= COUNTDOWN_MS) {
        gateServo.write(GATE_OPEN);
        stateStartTime = millis();
        currentState = FIRE;
      }
      break;
    }

    case FIRE:
      if (millis() - stateStartTime >= FIRE_DURATION_MS) {
        gateServo.write(GATE_CLOSED);
        setMotorSpeed(IDLE_PWM);
        stateStartTime = millis();
        currentState = RESET_STATE;
      }
      break;

    case RESET_STATE:
      if (millis() - stateStartTime >= RESET_DELAY_MS) {
        currentState = IDLE;
        Serial.println("Ready for next ball.");
      }
      break;
  }
}

void setMotorSpeed(int pwmValue) {
  analogWrite(MOTOR_A_PWM, pwmValue);
  analogWrite(MOTOR_B_PWM, pwmValue);
}

int readSpeedDial() {
  int raw = analogRead(SPEED_POT_PIN);  // 0 to 1023
  return map(raw, 0, 1023, MIN_LAUNCH_PWM, MAX_LAUNCH_PWM);
}

Calibration and safety

Calibration procedure

• Bench test with the wheels and gate only, no dog in the room, and watch several full cycles to confirm the 3 second delay is consistent.
• Set the dial to minimum and measure where the ball first lands. Adjust MIN_LAUNCH_PWM until that is about 3 ft.
• Raise MAX_LAUNCH_PWM in steps of 10 to 15, with the dial at maximum, until the first landing point reaches 15 ft. Stop there and record the value.
• Tune the wheel gap and feed ramp until throws are repeatable from ball to ball.

Safety design choices

• The wheels are fully enclosed. The only openings are ball-sized, so paws and noses cannot reach moving parts.
• Only 12V low-voltage power is exposed to the build, with a fused supply and common grounds.
• The IR beam is positioned so that only a ball resting on the gate can trigger it, not a curious nose at the funnel opening.
• A 15 to 20 degree exit angle and a firmware speed cap keep every throw inside the room.
• The countdown beeps give the dog a consistent cue to move away from the exit before launch.
• Early sessions are supervised, and the exit path is kept clear of furniture, people and breakables.

Next steps

• Bench test one wheel pair against a tennis ball to confirm grip and nip width.
• Prototype the funnel, gate and feed ramp in cardboard before cutting final panels.
• Wire the electronics on a breadboard and run the sketch with the motors disconnected.
• Complete range calibration, then build the final enclosure around the proven mechanism.