Enchanted Rose 2.0 with Falling Petals

Revisiting the Enchanted Rose project four years later, this time with an open-source build based on Raspberry Pi.

Enchanted Rose 2.0 with Falling Petals

Got a performance of Beauty and the Beast coming up? For about $200, you can build this Enchanted Rose with Falling Petals.

Dropping The Petals

There are a few approaches to make the petals drop. You’ve got a microcomputer (a Raspberry Pi) which can send electrical current HIGH or LOW on an output pin. How do you translate that into petals physically dropping on command?

In version 1.0, I used servo motors to pull fishing line. That fishing line was attached to a spring-loaded magnet in the bud of the rose. When the fishing line was pulled, the magnet would retract into the bulb and drop the petal. This worked very well, but it’s a delicate mechanism and wouldn’t ship well, and I wanted the 2.0 design to work for shipment.

After horsing around with solenoids (which didn’t work very well because they (a) were too bulky and (b) weren’t strong enough), the design I ultimately settled upon was to use individual, cheap 6v air pumps to push air through a small opening, and blow out a toothpick, to which a petal was attached. I found that I could “overclock” the air pumps at 12V (higher than rated) to push slightly more air out than rated. As long as the rose petals remained relatively light, bingo, it works. Here’s an in-progress video:

Just some notes to the person who bought this prop, but it gives you an idea of the functionality of the final 2.0 design. It also shows how the cloche can interfere with the falling petals if not set properly. TIP: Find as wide a cloche as you can.

Here’s an earlier video showing mock petals which were much lighter — tissue paper:

Design Goals

  • Drop 4 petals on cue, one by one
  • Turn on and off stem lights
  • Turn on and off accent lights, set color
  • Easy to reset between productions
  • Wireless — allow to be set on a pedestal on stage
  • Control via mobile web browser
  • Durable enough to ship
  • Do NOT require that it connect to a local internet
  • Easy to use interface that an elementary school stage crew could use
  • Easy on-site setup. Ideally, just turn it on and it works.

Parts List

image-202302051417313372 half breadboards
image-20230205142057108Raspberry Pi: I used a Raspberry Pi Zero 2W, but any Raspberry Pi which has onboard wifi will work, such as a 3B+, 4, Zero W, etc. Do not choose a Pico; that’s a different product line. You’ll also need a MicroSD card to store the operating system.
image-20230205142134583Jumper wires
image-20230205142242583Cloche: This was the widest and tallest one I was able to find for easy ordering. But I really did prefer the one I was able to find for the 1.0 build 4 years ago. This one is just barely big enough. Shop around — you may have better luck finding a wider one in a local arts and crafts store. You really want one that is fairly wide, because the petals need to fall freely and not get hung up against the side.
image-20230205142448526Stem “fairy” lights
image-20230205142615347Neopixel lights
image-2023020514265009611 AA batteries
image-20230205142809941One 8-AA battery pack
image-202302051428421814 pumps and tubing (you’ll need 2x of these three)
image-20230205143132807Enchanted Rose with silk petals – look for lightweight petals. The standard one on Amazon is too heavy — I went to Etsy to shop for mine.
image-20230205143602612Toothpicks — You are looking for ones which slide in and out of the aluminum tubing very easily, but which also block the most amount of air (to build up pressure — you need some force on these to pop the petal.)
image-20230205143254231Aluminum metal tubing (small) — The purpose of these aluminum tubes is to eliminate a lot of friction that existed between the toothpick and the pneumatic tube. In other words, toothpicks and these tubes sort of act like a blowdart. By using aluminum tubing as a gasket within the pneumatic tubing, a lot of the friction is reduced.
image-20230205143534234heat shrink
image-202302051433527185 Transistors: [TIP102]
Soldering iron, solder and flux
image-202302051437064524 Diodes: 1N4004 or MUR340
3.3v to 5v level converter: 74AHCT125
Coat hanger
Cigar box or wooden box for the base componentry
Wire clippers
Drill and bits
Hot Glue Gun and Hot Glue
Multimeter (helpful but not required)
Cigar box, wooden box or other case for components below the cloche
Pipe insulation foam for vibration-dampening, to just fit around the pumps
Parts List

Before You Begin

You’ll want to get your Raspberry Pi set up with Raspbian OS on a micro-SD card. Make sure you have SSH access to your RPi. You might also want to set this up to present its own SSID/wifi network. I’ve got a blog post on that here.

If you’re new to Raspberry Pi, here’s one video to get you started in setting up the operating system and SSH:

I also loved using Visual Studio Code’s “SSH” remote features. Setting this up can be a tiny bit tricky, but stick with it. Once you get this working, it’s incredibly productive. It allows you to use your desktop (Mac, Windows or Linux) to work with files and directories on your RPi.

NeoPixels will also require ROOT-level permissions on your Raspberry Pi to install some drivers. Now, there are all kinds of security folks telling you that using root on your Raspberry Pi is a bad practice for stuff like this. But since this is a simple stage prop, I had no problem with the idea of just using my root user and a password for the entire build, and it saved a lot of file permission headaches to just be “root” and be done with it:

Set a password for the root user, reboot your pi, and connect in as root from then on. While it may not be “best practice” for security, trust me, you’ll save a lot of headaches with installing libraries etc.


There’s both a hardware circuitry part and a software part. Let’s get some of the basic circuitry working first.

For ease of explanation, the hardware components can be thought of as three different “zones,” all powered by a single Raspberry Pi. These zones don’t need to talk to one another, except that all ground wires should be connected together and also to the RPi’s GND pin.

There are two zones powered by 4.5V: The Fairy lights and the Neopixel lights. There is one zone powered by 12V: the pump zone.

(DO NOT power the Neopixel lights with the 8 AA batteries (12V) used to power the pumps, as you will permanently damage the Neopixels!)

Zone 1: Control the stem lights (4.5V)

Let’s start here, because it’s the easiest circuit. These fairy lights are controlled by 3 AA batteries (4.5V.) You want to be able to have a GPIO pin on the Raspberry Pi toggle tell a transistor to allow current to flow to power these lights.

Cut the fairy light wire, and strip the ends. It’s a bad idea to power the LED directly from the Raspberry Pi, as altogether, the current draw might be more than the Pi can handle. So, you’ll want to use a standard Transistor (like a TIP 102) to switch the current.

Now, run a wire from the GPIO pin of choice — I chose pin 25 (BCM) — to the “base” pin of the transistor. When this is toggled HIGH, it will close the circuit of the LED fairy lights and thus turn them on or off programmatically.


Zone 2: Control the 4 pumps (12V)

The main mechanism to drop these petals is to blow air through tubes which have loose petals. I chose to cut some aluminum tubing to reduce the diameter of airflow and also to reduce the friction with the wooden toothpicks:

A close-up of one of the petals. You can hot-glue a toothpick into red silk. Placing these petals into the metal tubes allows the pump to then “pop” them out when they turn on.

For the electronics, you need a diode for each of the 4 pump circuits, for the reasons described in this video (where this video says “solenoid”, substitute in the “pump” in your mind — the same principle applies):

In my Enchanted Rose prop, I built a breakout board with a bunch of these MOSFET transistors and diodes. I overbuilt this board, making it with 6 different circuits when it only really needed 4. It’s messy looking, but pretty simple. Each of these circuits has a MOSFET transistor and a diode. Take care to get the direction of the diode correct — it needs to be pointing toward the positive load. (A diode is rather like a backflow valve in plumbing — it allows current to flow in only one direction, toward the “ring” on the diode.) The yellow wires in this photo below come from the Raspberry Pi (GPIO pin) and when they are HIGH, they allow current to pass from the “Base” of the transistor to the “Emitter.”

Basically you want four circuits which allow the GPIO pins on the RPi to turn on and off the motor. A single such circuit looks like this. (Note that instead of a 9V battery, I “overclocked” it with a 12V battery pack — I found these pumps can handle short bursts of 12V.)

Each pump motor needs a circuit like the below. Since RPi cannot output 9V, we’ll make use of a transistor to switch a supplied 9V current on and off. (Note that in production, I ended up boosting the power supply to 8 AA batteries, or 12V. The motors can handle this higher voltage for short duration, even though they’re rated for 6-9V.)

imgWiring diagram for pump motors

When you make six such circuits on a PCB board and don’t spend too much time cleaning up the build, it looks like this:

I chose Broadcom pins 21, 26, 6 and 5 to control the air pumps, as the python code shows.

I cut insulation foam for these motors (pipe insulation) which helps reduce the vibration sound a bit.

Battery pack; there are pumps inside these foam cylinders; the foam helps dampen some sound

Since these motors generate current spikes when they are powering down and powering up, it’s very important to protect your RPi with a diode, as follows (the directionality matters! pay attention to the line on the diode and the positive lead from the motor):

Zone 3: Control the Neopixel accent lights (4.5V)


The python code to control the Neopixel needs a set of libraries called “CircuitPython” to work. You’ll need to follow the NeoPixel Adafruit guide to installing CircuitPython.

I strongly recommend you read through the NeoPixel to Raspberry Pi Wiring Guide on Adafruit, which is likely to be more up-to-date than anything I’m providing here. I went to a 74AHCT125 level-shifter chip to map the Raspberry Pi’s 3.3v output to proper 5V levels. Note that the power cord shown in the diagram below simply feeds out to the 4.5V battery pack. The ground rail needs to be connected to the RPi’s ground rail. All the grounds in this project all connect together, and connect back to the Rpi’s ground. You can and should run both the LED fairy lights and the Neopixels off the same battery pack.


Then, check out the “neopixel_control.py” code that I put up on Github.


I’ve published two Github repos that should really accelerate your work here.

First, let’s run through what you need, because it’s helpful to see this at a high level. If you want to go the easiest possible route, set your RPi to render its own wifi network, and make sure you configure your Raspberry Pi so that it is known as on its own wifi network; that’s what the software is built for.

You will need the following software components set up:

  1. Software to tell the GPIO pins what to do and render it as an “API” which can be called. That’s the purpose of this Enchanted Rose Flask API Repository on Github.
  2. Website software to deliver a nice user interface so that people don’t need to call an API directly to change the lights, drop the petals. See this Next JS Front-End Repository on Github. Run this on an Apache web server on the Raspberry Pi. To do this, set up an Apache Web Server on your Raspberry Pi. Make sure it’s working by visiting the IP address of your Raspberry Pi from a web browser. Next, take the “out” folder from the repository above, and place it in your Raspberry Pi’s /var/www/html folder. You should then have a web front-end that is calling locally to the device’s Flask port (hardcoded in the source as:
  3. Set up the web server and the API, and make sure they start properly at Raspberry Pi boot-up.
  4. Make your Raspberry Pi its own local wifi network, so you don’t have to rely upon tapping into the router or a network wherever your production happens.

Configuring Raspberry Pi for “Ad Hoc Network”

Now, how do we get a mobile phone to reach the Raspberry Pi? Of course, if we know the networking details at the production venue, we could in theory just have the RPi join the wifi network of the theatre, and then somehow go to the theatre’s router settings and look for its address. But that’s a pain and doesn’t scale well.

So I was excited to hit upon the idea of having the prop create its own “Ad Hoc Network” (i.e., it’s own Wifi SSID that you can join.) Not only does this eliminate the need to have the stage manager at each playhouse somehow find a way to connect the prop into their own local network, but it removes any requirement for a display or keyboard to ship with the device for configuration purposes.

All they you to do is plug in the device, wait for boot-up, and it presents its own Wifi Network (“EnchantRose”.) You then simply enter the password, bring up a web browser on their phone, and visit a pre-determined IP address which I’ve configured:

It took a while to figure out how to configure Raspberry Pi to do this, since the instructions have changed seemingly with every release of Raspbian, the RPi operating system. But I figured it out by adopting existing instructions, and blogged about it here. The steps in that blog post provide all you need to do to get your Raspberry Pi setting its own network. To ensure the Enchanted Rose repository code works, be sure to set your network to the instructions given — you want the RPi to be able to reference itself on its own network as

What’s most exciting about this is that it’s a pattern that can has many applications in the world of “Internet of Things” — run Apache2 on your Raspberry Pi to host a website, and render that website visible via the Rpi’s own password-secured wifi network.

Current Status

The new version 2.0 prop is fully functional. I’ve sold it and shipped it to one of the many production managers who have inquired. As this post continues to get indexed by Google, I get hit up for these builds; at this writing it’s over a dozen such requests, from FL, CA, HI, UK, NJ, CO and more.

UPDATE, late January 2023: This 2.0 prop is sold to a production in Hawaii, and has been shipped off.

I’ve decided for now that the logistics and expense of shipping these out to productions is just too complicated, but I’d love to hear from you if you’ve built one of these. If you’ve got specific questions on assembly or the software, drop me a note. On with the show!

Build Your Own Enchanted Rose Prop (Part II)

Part 1 of this article covers the basic parts list, code, and assembly.

UPDATE (January 2023): I’ve built a version 2.0 of this prop. See “Enchanted Rose 2.0: Raspberry Pi Prop with Falling Petals” for updated instructions. 

UPDATE (April 2021): The Bluetooth shield used in this Arduino-based project is apparently discontinued. If I were to build this project again today, I’d make it a Raspberry Pi Zero W with Headers (or 3B+) based device. Take note on that order page of the adapter cables and power supply you should also get.

The RPi would run a simple Flask (python) server to control the servo motors. I’d attach an Adafruit Servo Motor HAT to do the servo motor control, and then build a simple web application to control the prop. This would eliminate all the Swift Coding involved in the app controller, and allow for much easier building/debugging. I would absolutely use the same drop mechanism. That is, servo motors, spring loaded magnets mounted in a wooden golf-ball sized drawer handle.

To be clear, this updated approach would mean I would not order the Redbear Labs BLE shield nor the Arduino, nor would I futz with the fun but unnecessary iOS app. But nothing prevents you from building a nice one to control a Raspberry Pi based prop!

Now that the Enchanted Rose Prop is nearing completion, I wanted to cover a few final details. Here’s a video of the app and prop in its current form:

Aesthetic Touchup

Some paint and floral tape was used to give the stem a little more rose-like appearance. Still in progress, but you get the idea.

Ring Lights

The ring lights are a Neopixel 1 meter long strip. I cut the strip between the LEDs at roughly the 40 LED mark. Doing so has no effect on the Neopixel, as long as you cut between LEDs.

Big gotcha: These lights only want 5V maximum! I fried the first set by overpowering it. Don’t make that mistake — it’s irreversible.

Stem Accent Lights

I purchased a cheap set of LED lights to add some interest to the stem.

These are powered by their own 3-AA battery pack. I’m sure I could use the same 3 AA-battery pack used by the Neopixel strip, but after frying one of those strips, I chose not to risk wasting another $30 tempting fate. To turn these on and off, an N-channel MOSFET transistor is used, with its gate actuator tied to pin 10 of the Arduino.

Basically, the MOSFET transistor lets current pass through if voltage is applied to the Gate pin (pin 1 in the diagram above.) When voltage on the gate goes LOW, the LED accent lights turn off. When voltage on the gate goes HIGH, the accent lights turn on.


The servo motors are a little squeaky when moving. I installed some foam sound barriers (ordinary shipping packaging) to help dampen the sound.

Drop Mechanism

The initial approach of using piano wire to move flexible wires up and down worked fine from a dropping standpoint, but it had two distinct disadvantages in practice:

  1. the vertical extension above the bud made it hard to get the upper petals to to look real
  2. the “re-set” procedure was going to be way too hard for young adults to do Did I mention that after I had the prop working for an adult, my wife told me that the crew would be entirely comprised of fifth graders? “Hardening” the prop for fifth grade use for 8 performances in ways such as this was actually the most time-consuming part of the project.

So instead, I revised the attach/drop mechanism, to fishing-line-pulls-a-magnet.

I drilled four holes into a wooden 1 1/2″ golf-ball. Tip: use two drill bits, a small one that goes all the way through (just for the fishing line), and a wider one for the hole where the spring mechanism sits. You’ll want to give the spring something to push against, so don’t go all the way through the wooden ball with the drill, as I mistakenly did.

The key part are rod magnets which are inserted into thread covers and put into a spring:

I later added rubber caps over these magnets (but first drilled a small 6mm hole in the center.) I then hot-glued these caps-with-holes over these magnets. In “normal” state, the magnet protrudes through the caps to make surface contact with the washers inside the petals. When the Servo motor moves, it temporarily (2-3 seconds, programmable delay) pulls the fishing line which separates the magnet from the petal, and then resets it to the normal position. The advantage of this design is that it only uses servo motor power during the drop operation.

Result: TOTAL SUCCESS. Worked flawlessly in production and could even be re-set by kids (though I admit I double-checked pre-show.)

The fishing line is pushed through the (orange) nylon thread cover and a double knot is used to prevent it from pulling through. Then, the rod magnet is inserted, finally that’s inserted into a spring. That subassembly is repeated three more times, and inserted into the four holes in the wooden “bud.” You’ll want to make the exit hole for the fishing line quite a bit smaller than the upper hole, so the springs have something to push against. The only thing that comes through the bottom of that wooden ball is four strands of fishing line, which are fed down into the stem, one to each of the four servos.

The petals have a small metal washer hot-glued to the base, which is magnetically attached to the bud. When the servo motor turns, the rod magnet is pulled down about a half inch to an inch into the chamber, and this action causes the petal to fall. The servo motor returns to “slack” position and the spring returns the rod magnet back to its ready position.

The petals can then be reattached.

This drop mechanism is much more durable, and now that the magnets are “self-resetting”, I’m thinking of switching the slider-control based drop mechanism to a simple push-button interface.

(Update: I did so, and those changes are reflected in the Github code. It’s a simple four-button interface for the drop mechanism, one for each petal; this initiates a retraction of the servo, a pause for a second or so, and then restoration to the ready position.)


The performances— all eight showings — were smashing successes!

Izzy, the fifth-grade prop controller, did a great job controlling it and the prop functioned just as designed.

Izzie and The Rose Prop

If there was a flaw, it was that one of the petal drops (of the 32) worked but got hung up on the LED light bush below it, so it appeared not to drop, but that was pretty minor and not a big deal.

Note that I did decide to replace the full set of AA batteries in the entire prop after the fourth performance. I can’t speak to whether that was unnecessarily premature, but there were no battery failures. Each performance was about 90 minutes, and the power to the prop was turned on about a half hour before and after each performance.

The Enchanted Rose Prop is now in the hands of the school theater director (and computer tech teacher; she’s one and the same) as a partial thank-you for all her great work with the kids.