Build a Grabbing Candy Bowl with an Ultrasonic Sensor

Halloween is on October 31, which makes this a good week for a prop with a little attitude. This bowl waits quietly until a hand reaches in. Then a piezo shrieks and a servo swings a rubber hand down to grab back. You will build it in Mokxi, learn how the sensor tells a hand from empty air, and add a cooldown so one reach gets one grab.

It follows Mokxi's built-in Grabbing candy bowl example. The sketch below is my own version of it, with a timed cooldown added. If you want a prop with a lid and a scream instead, the jump-scare box is a different build, so I will not repeat it here.

What you need

• An Arduino Uno.
• An HC-SR04 ultrasonic sensor.
• A hobby servo.
• A piezo buzzer (a passive one, so tone() can set the note).
• Jumper wires and a breadboard.

An ultrasonic sensor works like a bat. It sends a short burst of sound you cannot hear, then times how long the echo takes to come back. The longer the wait, the farther away the object is.

Wire it up

Part	Pin	Goes to
HC-SR04	VCC	Uno 5V
HC-SR04	GND	Uno GND
HC-SR04	TRIG	Uno pin 7
HC-SR04	ECHO	Uno pin 8
Servo	VCC	Uno 5V
Servo	GND	Uno GND
Servo	PWM	Uno pin 9
Piezo	one leg	Uno pin 4
Piezo	other leg	Uno GND

Mount the sensor on the rim so it looks across the top of the bowl, not down into the candy. Pointed into the bowl it would always see something and never rest.

The complete sketch

#include <Servo.h>

const int TRIG_PIN = 7;
const int ECHO_PIN = 8;
const int SERVO_PIN = 9;
const int PIEZO_PIN = 4;

const int GRAB_CM = 12;
const int CLEAR_CM = 20;
const int HAND_UP = 20;
const int HAND_DOWN = 150;
const unsigned long COOLDOWN_MS = 3000;

Servo hand;
int closeReadings = 0;
unsigned long lastGrab = 0;
bool everGrabbed = false;

int distanceCm() {
  digitalWrite(TRIG_PIN, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIG_PIN, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIG_PIN, LOW);
  unsigned long echo = pulseIn(ECHO_PIN, HIGH, 30000UL);
  if (echo == 0) return 999;
  return echo / 58;
}

void shriek() {
  for (int freq = 1800; freq > 600; freq -= 100) {
    tone(PIEZO_PIN, freq, 40);
    delay(45);
  }
  noTone(PIEZO_PIN);
}

void grab() {
  hand.write(HAND_DOWN);
  shriek();
  delay(600);
  for (int angle = HAND_DOWN; angle >= HAND_UP; angle -= 5) {
    hand.write(angle);
    delay(25);
  }
  lastGrab = millis();
  everGrabbed = true;
}

void setup() {
  Serial.begin(9600);
  pinMode(TRIG_PIN, OUTPUT);
  pinMode(ECHO_PIN, INPUT);
  hand.attach(SERVO_PIN);
  hand.write(HAND_UP);
  Serial.println("Candy bowl ready");
}

void loop() {
  int cm = distanceCm();
  closeReadings = (cm < GRAB_CM) ? closeReadings + 1 : 0;

  bool rested = !everGrabbed || millis() - lastGrab >= COOLDOWN_MS;
  if (closeReadings >= 2 && rested) {
    Serial.println("Hand detected: grab!");
    grab();
    while (distanceCm() < CLEAR_CM) {
      delay(60);
    }
    Serial.println("Hand gone");
    closeReadings = 0;
  }
  delay(60);
}

Walk through it

Lines 1 to 17 are setup material. The pins are named, and so are the numbers that shape the show. GRAB_CM is 12: anything closer than that is a hand. CLEAR_CM is 20: the hand has left once it is farther than that. HAND_UP and HAND_DOWN are servo angles in degrees. COOLDOWN_MS is 3000, three seconds of rest.

distanceCm() does the sensor's two-step dance. It sends a 10 microsecond pulse on TRIG, then pulseIn measures how long ECHO stays high. The sound travels there and back, and about 58 microseconds of that time is one centimeter of distance, so dividing by 58 gives centimeters. The 30000 is a time limit. If nothing echoes, the function returns 999, meaning "nothing there".

shriek() loops through falling pitches, 1800 hertz down to 700, 40 milliseconds each, which sounds like a wail that dies away. noTone ends it.

grab() swings the hand down in one move, shrieks, holds for 600 milliseconds, then lifts the hand back in small 5 degree steps. A slow lift looks much creepier than a snap. At the end it records the time in lastGrab.

loop() is where the thinking is, and it has three layers of protection:

1. The threshold. cm < GRAB_CM counts as a close reading.
2. Two in a row. closeReadings counts consecutive close readings and resets to 0 on any far one. An ultrasonic sensor sometimes hears a stray echo, and one bad reading should not set off the prop.
3. The cooldown. rested is true if the bowl has never grabbed, or if 3000 milliseconds have passed since the last grab. The grab only fires when both conditions hold.

After a grab, the sketch waits in a small loop until the distance is past 20 cm. That is the gap between 12 and 20: the bowl wakes up at 12 centimeters but only relaxes after 20. This gap is called hysteresis, and it stops a hand hovering near the edge of the range from setting the bowl off again and again.

Run it

Add the parts, make the connections, paste the sketch and press Run. The serial monitor prints "Candy bowl ready". Now drag the sensor's distance slider under 12 centimeters.

I tried exactly this in the simulator. The serial monitor printed "Hand detected: grab!", the servo swung down and lifted, and "Hand gone" appeared once I slid the distance back out. When I moved my pretend hand back in about a second later, nothing happened. The next grab came only after the three seconds were up.

Notes for a real bowl

• A servo can pull a lot of current when it starts, which can sag the Uno's 5 volts. On a real build, give the servo its own 5 volt supply and join its ground to the Uno's ground.
• Pad the rubber hand so it bumps rather than pinches.
• Test with the sensor aimed at an empty room before you add candy.

What to try next

• Change GRAB_CM to 8 for a bowl that waits until a hand is deep inside.
• Raise COOLDOWN_MS to 10000 for a longer rest.
• Swap the notes in shriek() for a rising sweep instead of a falling one.
• Count the grabs in a variable and print "Grab 1", "Grab 2" on the serial monitor.
• Open the Grabbing candy bowl project and compare it with the sketch above.

For more on the parts, see the HC-SR04 page and the servo page. The ultrasonic sensor guide goes deeper on the echo timing.

Ready to build it yourself? Create your free Mokxi account and open the editor in your browser. No installs, no parts to buy.