I Cut the Head Off a Snowman and Built a Radar Robot Inside

I Cut the Head Off a Snowman and Built a Radar Robot Inside

This snowman is asleep. Walk into the room and he wakes up, turns to look at you and waves. Stand and chat and he joins in, nodding along. Step too close and his star turns red and he shakes his head at you. He’s decided you’ve been naughty.

There’s no hand inside him. There’s a Raspberry Pi Pico 2 W, four servos, a 24 GHz radar and a 3D printed skeleton. And to get it all in there, I had to cut his head off.

This is my Christmas build, and it’s the follow-on from my Halloween skull. The skull taught me the foundations of animatronics: smooth servo easing, a radar that sees through plastic, and a simple state engine. The question for the snowman was simple: does it scale? Twice the servos, a soft body instead of a hard shell, a skeleton I had to design from scratch, and a character that needs to feel friendly rather than predatory.

The Halloween radar skull next to the finished robot snowman

The build is a three-part video series, and this post pulls all three together.

PartVideoPublic on YouTube
1, the bodyI Cut the Head Off a Snowman to Build a RobotOut now
2, the brainMy Servo Library Said 3 Servos Max for this board. I Needed 4Thu 26 Nov. Members can watch now
3, the personalityWho’s Been Naughty? My Radar Snowman DecidesThu 3 Dec. Members can watch now

What he does

  • Sleeps until someone comes into the room, with a slow blue heartbeat in the star on his hat.
  • Wakes up and looks at you, turning gently if you’re standing still and snapping round if you walk past.
  • Waves hello when you come close, and dances if you stay.
  • Joins in a conversation when you stand in front of him: nods, waves and the odd shake of the head.
  • Likes his personal space. Under a metre, his star goes red and a head shake gets up to eight times more likely.
  • Looks around when he’s bored, and dozes off again when everyone’s gone.

It all runs on one radar reading: how far away you are.

What’s inside

PartWhat I used
SkinA Little Town snowman plush hand puppet, bought second hand. I couldn’t find a new one, but there are plenty on eBay and Vinted
SkeletonA stack of 3D printed cylinder sections, designed in Blender
BrainRaspberry Pi Pico 2 W (RP2350A)
Driver boardThe servo driver board from my Robot Santa build, reused. It takes a Pico or Pico 2
MovementFour hobby PWM servos: head pan, head tilt and one for each arm
SensorKeywave KW307 24 GHz radar, the same one as the skull
LightsA 7 LED WS2812B disc, now a star badge on his hat
Head liningAn old white sock

Everything, including the 3D models, is on GitHub: github.com/DrJonEA/Snowman2026.

Part 1: the body

The snowman glove puppet before surgery

Why start with a glove puppet? Because it’s already most of the way there. It’s soft, it’s shaped, it already has character, and it’s hollow: it’s designed to have something inside it. Normally that’s a hand, and that’s the problem. A hand moves everything from below. Your fingers push the head, your thumb and little finger work the arms, and nothing turns on its own.

A servo needs the opposite. It needs a solid mount to push against. I wanted the head to pan and tilt on its own, and each arm to move by itself. So the puppet had to change to fit the robot, and the robot had to be designed to fit the puppet.

The puppet with its head cut off at the neck, and the finished snowman with his head back on

After a lot of thinking, the head came off. I cut right around the neck. The head becomes a cap that sits on a plate at the top of the pan and tilt mechanism, so wherever the plate goes, the face goes too. The body becomes a sleeve, a tube of fabric that slides down over the skeleton, with the puppet’s arms sliding over the robot’s arms.

The headless puppet body opened up like a sleeve, with the base plate of the armature

Cut fabric frays, and worse, the stuffing falls out between the lining and the fur. So every cut edge had to be re-sewn. I’m not great at sewing, I’ll be honest, but it held.

The head needed one more trick. On its own, the fabric was a bit too tight and small to cover the neck mechanism and still hide it. So I sewed in a new lining: an old white sock. It gives the head enough stretch to turn and tilt, and from the outside you’d never know. If you’ve got a white sock that’s lost its partner, now you know what to do with it.

Inside the head cap: the sewn-in white sock lining

Designing the skeleton

Before I modelled anything, I wrote a list. The skeleton has to fit inside the puppet’s body, hold four servos, house the control board, give the radar a clear view out of the front with no metal in the way, get power up to the star on his hat, and come apart again for repairs.

The design is a stack of 3D printed cylinder sections, each doing one job. The control board sits at the bottom, the arm servos in the middle, and the pan and tilt mechanism on top. The pan axis is about 13 centimetres above the base, which puts his face where the puppet’s face should be.

The arm design in Blender: bent rods on servo horns

The arms are the interesting bit. A hand in a puppet squeezes the arms rather than lifting them, so my servos swing the arms forwards and back in front of him, like a hug or a wave. Each arm is a rod with a bend of about 30 degrees, so the hand sits forward of the body like the puppet’s did, and the puppet’s sleeves slide straight over.

The radar sits behind a window at the front. Radar sees through plastic, which is how the skull hid it completely, and it sees straight through the armature and the puppet’s fur too. Once he’s dressed, there’s no sign of a sensor at all.

One thing that paid off later: I measured where everything ended up. The height of each joint, the length of each rod, the angle of each bend. Those numbers went straight into the code in Part 2, so he knows where his own hands and head are.

The mistake: I didn’t model the bolts

I modelled every part carefully. What I didn’t model was the bolts. On screen, everything fitted perfectly. In the real world, the sections wouldn’t slide together because bolt heads were in the way. Out came the Dremel.

Tip: model your fasteners as real parts: the bolt heads, the nuts and the inserts. Then the clash shows up on screen, where it costs you nothing, not on the bench, where it costs you a reprint.

I also damaged a servo. One of the arms I printed for the head was too short, the servos clashed, and the gears paid for it. It happens.

The bare 3D printed skeleton, and the snowman with his skin back on

Skin back on, he’s the same snowman from the outside. Same smile, same scarf. Just a little taller, and a lot more robot.

Watch Part 1: I Cut the Head Off a Snowman to Build a Robot

Part 2: the brain

Rather than design a new PCB, I reused the driver board from my Robot Santa build, with a Pico 2 W plugged in. Reusing a board I’d already proved saved me a PCB order and the wait for it to arrive. It came with one catch.

Wiring: the KW307 on UART1, four servos on PWM slices 1 and 2, a spare on slice 3, and the star on GPIO5

The board brings out five PWM servo headers on GPIO 18 to 22, the star on GPIO 5, and the radar on UART1 (GPIO 8 and 9, labelled Trig and Echo because the board was designed for an ultrasound sensor). Those five headers sit on just three PWM slices.

My servo library said three servos max

On the Pico, the PWM hardware is split into slices. Each slice has one counter and two outputs, channel A and channel B. Both channels share the counter, so they share a frequency, but each has its own duty cycle. That’s perfect for servos: every hobby servo wants the same 50 Hz signal, and only the pulse width changes. Two servos can share a slice happily.

On the skull I used da-luce’s pico-servo library, and I love it: easing curves, timed moves and callbacks, all driven from the PWM wrap interrupt, so the main loop stays free. But it tracks one servo per slice. Three slices on my headers meant three servos, and I needed four.

So I forked it and changed three things:

  1. The servo table is indexed by slice and channel, so each slice holds two servos, A and B.
  2. The shared interrupt: each slice fires one wrap interrupt, so the handler now steps both servos on that slice, and only switches the interrupt off when both have stopped moving.
  3. A critical section around starting and finishing a move, because one can come from my code and the other from the interrupt at the same moment.

The head is now on slice 1 (pan on A, tilt on B) and the arms on slice 2 (left on A, right on B), with 3A spare. On the RP2350A that’s up to 16 servos instead of 8. The fork is at github.com/drjonea/pico-servo, and it’s a submodule in the Snowman repo. I plan to offer it back to the original as a pull request.

Then the arms stopped waving

With the library fixed, everything worked on the bench: four servos, smooth easing, lovely. Then I set up to film, and the arms faltered and stopped short. Same code, same board, same servos.

The culprit was an extension lead. I’d added it to get the power cable out of shot, and it couldn’t carry the current. Nothing looked wrong: he powered up, the star lit, the head moved. It’s only when several servos move at once that the current jumps, the voltage sags, and the arms run out of push.

Tip: servo current comes in bursts. A thin or long lead can look fine at idle and fail under load. Check the lead’s rating, keep the run short, and if something odd happens, measure the voltage at the robot while it moves.

Kinematics, animations and a star

Servo angles aren’t a good way to think about a snowman. I want to say “look at that person”, not “pan servo to 112 degrees”. So I built a small kinematic framework with the Eigen library. Each limb is a chain of fixed offsets and rotating joints, using the measurements from Part 1. Forward kinematics tells me where his hand or face is for any servo angle; inverse kinematics gives me the angles to point at a spot in the room. The chain also handles his limits: the head pans 45 degrees each way and tilts 25 up or down, the arms are mirror images, and the tilt servo is mounted upside down, so the code flips it in one place.

On top of that sits a simple animation class. An animation is a list of steps, each with an action (move the head here, with sine easing) and a wait. It’s polled from the main loop, so nothing blocks, and several animations run at once while the star keeps animating. He can wave with either hand, hug, nod, shake his head, look around and dance.

The star is the same 7 LED WS2812B disc I used for the skull’s eyes: one LED in the centre and a ring of six. A chase runs around the ring and a heartbeat pulses in the centre, and the colours and speeds give him a mood.

The KW307 is read exactly as on the skull: by interrupt on UART1 at 115200 baud, handed to Keywave’s SDK, with a callback that stores the numbers and gets out. Never move a servo from inside an interrupt.

Watch Part 2: My Servo Library Said 3 Servos Max for this board. I Needed 4 (public on 26 Nov; members can watch now)

Part 3: the personality

A state machine inside a state machine

My skull had a flat state engine: asleep, falling asleep, watching and hunting. Fine for a skull that just stares at you. A friendly snowman needs far more states, and a flat state machine gets messy fast. Take “go back to sleep”: with six awake states, I’d need six arrows back to Asleep, and I’d forget one.

So I wrote a small hierarchical state machine, about 300 lines of plain C++ with no hardware ties. States can live inside other states, and an event that isn’t handled where you are bubbles up to the parent. So “go to sleep” is one transition, on Awake, and it works from anywhere inside it.

The snowman's states: Asleep, and Awake containing Waking up, Idle, Looking, Greeting, Entertaining and Attending, which has its own Nod, Wave, Shake and Pause

Here’s his whole personality:

  • Asleep: slumped, the star’s ring dark and a slow blue heartbeat every four seconds. When the radar sees a human, he moves to Awake, the ring chases and the heartbeat goes red and faster.
  • Idle keeps his head on whoever’s there and has a think every eight seconds. Nobody close? He goes Looking around the room. Three look-arounds with nobody there and he goes back to sleep.
  • Greeting: come close and he waves. Stay close and he moves into Entertaining and dances, then takes a 20 second cooldown so he doesn’t dance at you all evening.
  • Attending, my favourite: stand still in front of him, within about 45 degrees, and he joins the conversation, picking nods, waves and shakes with a pause between. He waves with the hand furthest from you, so it crosses his body towards you.

One fix from the last day of coding: if you’re already in front of him, he shouldn’t break off to greet you. That one guard made him feel far less twitchy.

One number: distance

Nearly every decision comes down to how far away you are.

How distance drives his star colour, his choice of gesture and the gap between gestures

  1. Near and far, with hysteresis. You’re near inside 1.5 metres, but you don’t count as far again until you’re beyond 2 metres. Without that gap, standing right at 1.5 metres makes him flip between the two several times a second.
  2. The star. Green at 2 metres or more, blue at 1 metre, red by about 70 centimetres.
  3. Naughty or nice. Gestures are picked at random, but weighted: a nod is most likely, then a wave, and a head shake is rare. Closer than a metre, the head shake’s weight climbs, and by 70 centimetres it’s eight times what it was. The gap between gestures is 2.5 seconds close up, stretching to 15 seconds at 3 metres, with a little random jitter so he never feels mechanical. He doesn’t hate you. He just likes his personal space.

How he turns to look also depends on you. Each radar frame boils down to one target: a stationary person wins, because that’s someone he can talk to; otherwise the nearest moving one. A still person gets a slow two-second turn with sine easing, ignoring changes under about 3 degrees so he doesn’t twitch at radar noise. Someone walking past gets the skull treatment: quick 50 millisecond moves with exponential easing. Predator mode, but friendly.

One honest fudge: the radar’s angle reads a little short on one side, so negative angles get 10% extra. Tuned by eye, but it works.

The hard part: trusting the radar

The states were the fun part. The hard part was the data. Standing still in front of him, the distance was mostly sensible, but every so often one frame would jump. With everything hanging off distance, one spike would flip his star red, knock him from near to far, or start a greeting. He looked nervous, like he was seeing ghosts.

Raw radar distance with spikes, and the filtered line that ignores them (an illustration with simulated readings)

So every frame now goes through a two-stage filter:

  1. A median of the last five readings. An average gets dragged towards a bad reading; a median sorts the five and takes the middle one, so a single wild value just ends up at one end and is ignored.
  2. A light exponential average, half the new value and half the old, to smooth what’s left.

Together they add about two frames of delay, which you don’t notice, and the spikes are gone. If he loses the target for ten frames, the history is cleared, so a new person doesn’t inherit the last person’s distance. It’s a trick that works on almost any noisy sensor.

The filterDistance function: a five-sample median followed by an exponential average

While I was in there I found three more problems:

  • A bug of my own: the loop that picked the nearest moving target had a break in it, so it picked the first one it found, not the nearest. One line deleted.
  • Dropouts: the radar sometimes loses a still person for a moment, ending the conversation and starting a greeting all over again. Now a stationary target is held for a second after it disappears.
  • Half a frame: the radar data is written in an interrupt and read in the main loop, so the loop could read a distance from one frame and an angle from the next. A sequence counter fixes it without locks: the callback adds one before it writes and one after, so the number is odd mid-write. The main loop reads the counter, the data, then the counter again, and starts over if it was odd or changed.

And the last lesson: starting a new move on a servo that’s still moving blocks the main loop, and when the main loop stops, the star freezes. So before each gesture he now waits for the last move to finish.

Watch Part 3: Who’s Been Naughty? My Radar Snowman Decides (public on 3 Dec, just before Krampus Night; members can watch now)

What the snowman taught me

The skull taught me smooth movement. The snowman taught me that a soft body, four servos and a radar are the easy bit. Personality comes from the state machine, and a state machine is only as good as the data you feed it. Filter your sensors.

If I did it again, I’d model every bolt, use a short, heavy power lead from day one, and put the filter in before writing a single state.

Build it yourself

Watch the whole series now

Parts 2 and 3 go public on 26 November and 3 December, but channel members can watch all three today. Members get every video the day I upload it, and your support pays for the parts, the filament and the hours that go into builds like this one. To everyone who’s already a member: thank you. You keep this channel going.

Join the channel here

If you’ve built something inside a puppet or a soft toy, I’d love to see it. Tell me in the comments: what should I animate next?


Part 1 of the video series is sponsored by wolfSSL. The Keywave link above is an affiliate link: it costs you nothing extra and helps keep the channel running. The components in this build weren’t sponsored.

Leave a Reply