Realistic Flickering Candles for a Prop Cake

I was a Tech Director for a local High School’s Theater Arts program. One of the scenes in a recent production, required a birthday cake with candles. Simple, right? However, the candles were lit and blown out several times on stage. Of course, real candles weren’t practical!

I transformed an old wedding cake prop into a birthday cake with simulated candles that could be controlled by the actress. And the candles had to be convincing. At least as I believed. No flashlights on the top of the cake!

The candle simulation was created with LEDs and an Arduino Nano – a computer on a 1.5”x0.75” printed circuit board.

This Instructable has two faces. One, how to create a birthday prop, which must hide any electronics. And the second “face” is the electronics which create the realistic candle effect. I’ll cover making LED based candles, wiring them to the NANO as well as wiring the control switches, and programming the Nano to create the effect.

[Tool/Parts]

First, I will present the Material & Parts I used in this project. You may not have everything and could use different parts, once you understand what they are used for.

• Solder
• Hot Glue sticks
• Project Adhesive (like Liquid Nails, but specifically for Styrofoam)
• 1” foamboard (insulation) (only need about 1 sq. foot)
• Self-adhesive Velcro tabs
• Coarse sandpaper (120 grit is good)
• 1 sq. foot ¼” (luan) plywood
• Heat Shrink tubing (various sizes)
• Arduino Nano
• Various colors 24g solid wire
• (6) ¼” neodymium magnets
• 2 SPST (or equivlent) miniature toggle switches
• 9V Battery plug

And here are the tools I used.

• Soldering iron
• Wire cutters and strippers
• Hot Glue gun
• Drill
• Saber saw
• Steak knife (with permission)
• Motor Tool (i.e. Dremel)
• Caulking gun
• 1” Paintbrush

A small top layer of the cake was constructed. It is hollow to hide most of the wiring and the Nano

The top of this cake topper was a circle cut from ¼” plywood. Its diameter is 2” smaller than the top of the existing cake prop. Drill a 1/8” hole in the center and five equidistant holes along the edge, 1-1/4” from the circumference. These are where the candles will be. One could get very OCD about this step. Would you draw a line along the radius to one side, then, get your protractor and measure out the remaining candle positions, as exactly 72 degrees? Nah, I didn’t either. I just eyeballed it.

Also, about 1-1/4” in from the circumference, drill a ¼” hole about ½” from one candle hole. This is where the power switch will go.

Using the plywood circle, trace its shape onto the styrofoam. Don’t cut it out yet. You need to draw a second circle on the plywood, 2” less than the outer diameter. This will create a ring where the electronics will fit. Note: if you can get a pre-made ring of the proper size from a craft store, there you go!

Cut out the circles. I used the steak knife here. Using the caulking gun and the project adhesive, lay a bead on the ring and place the plywood circle on top. Weight it with… something heavy! I used a stack of hardcover books, but use what you have on hand. A few bricks, large stones from the yard… Find something.

Let it dry overnight.

After the glue has dried, with the coarse sandpaper, sand around the ring so the assembly looks like a solid unit. Then, between where the hole for the power switch is located and the candle hole on the right, drill two ¼” holes through the ring. This is where we’ll mount the power indicator and run wires for the battery holder and control switch. It also defines the “back” of the cake.

We’ll use five bits to make our candles. A 2” length of red heat-shrink tubing (1/4” diameter), a yellow LED, a 150 ohm resistor and 6” pieces of red and black wire (24 gauge).

The heat shrink tubing is not being used as intended. It’s being used as a cylinder to represent a candle body.

LEDs have two different length legs. Warning: electronic terms ahead! The short leg is the cathode. It must connect to ground or the negative side of the battery or power supply. It’s a convention to use a black wire here (red wires connect to the positive side of the power source). So, remember this as we connect everything together.

Another thing is that LEDs need a resistor to limit the current through them. There’s some simple math to figure out what resistor is needed, but I’ve done that for you.

To start, bend the resistor lead at a right angle, a short distance from the resistor body. Wrap this resistor lead around the cathode of the LED. Solder the two leads together. Then, remove some insulation from the black wire, wrap it around the other resistor lead and solder. You should trim any excess wire from these joints.

Now, we’re going to use the heat-shrink tubing as intended. Cut a length long enough to cover the resistor, and both of its bare leads. Slide it on the wire, get a lighter and heat the heat-shrink until it covers and insulates the joints. We don’t want any bare wire exposed on this leg of the LED.

Now, strip the ends of the red wire and using the same technique, solder it to the other LED lead.

Before you go any further, if you have a 5V source, put the red wire on + and the black wire on -, and the LED should light up. 3AA batteries can be used for this test. If you don’t, I can almost guarantee you that one or more LEDs won’t light and you’ll have a hell of a time figuring out why.

Ok, you’ve soldered everything together. You might as well make and test all six. Start heating up your glue gun. Then, insert the LEDs into the heat-shrink tubing, until the lip around the bottom of the LEDs is still inside the tube. About 0.1”. Hot glue them in place. When the glue had cooled, use more hot glue inside the bottom of each tube. Don’t be stingy.

Ok. Now, when that’s cooled, a final detail. Using the hot glue gun again, place a generous blob on the top of each LED. Don’t move the hot glue gun. Wait a second or two for the blob to start cooling. Then S-L-O-W-L-Y pull the gun away from the tip. You’re trying to make the tip of a flame. You might need to snip it a bit, but that’s ok.

There! You’ve made six faux candles. In a few steps, we’ll make them look real.

Now, we’re going to use almost the same technique to make a power indicator. But this time, we’ll use a blue LED and a 330 ohm resistor. Oh, and no tube. But you could if you liked doing that It’d be less than 1” long.

Solder the resistor to the shorter wire. Solder the other end of the resistor to the black wire. Insulate with heat-shrink tubing. Finally, solder the red wire to the longer LED lead.

I used DPDT switches because I had them. The circuit only requires SPST switches. Typically, any two contiguous terminals along one side can be used as a SPST switch. Look at the two pictures. The one with the colored circles indicate the terminals that were used.

It would be easier if you had SPST switches as I called out in the parts list. They only have two terminals.

We’re going to use this switch to connect the + side of the power source to the rest of the circuit (Nano). So, both wires should be red. Yes, I know the picture shows white wires, but I had a good picture of the switch with white wires and none with red!

The prop candles will have two modes of operating: Candles are lit or Candles will be blown out. There is another switch (SPST or equivalent) to control this operation.

For this, I used white wire. First, there is no polarity required for the switch; it’s purely a signal. And secondly, the prop cake is white! White wire will help disguise the wire as it’s routed around and through the cake prop.

I cut two lengths of wire about equal to the height if the cake + the bottom diameter + four or five inches for extra.

I soldered these to the switch, and twisted them together lightly. And set it aside for assembly.

We start by putting the subassemblies that we’ve prepared in the previous steps, into the cake topper. You’ll need to strip these wire ends to solder. I won’t mention stripping the ends again, as it should be obvious. Use the wire stripping tool or any method with which you are comfy. I do not recommend any method of stripping wires that will give your dentist to track me down. I don't need no crazed dentists stalking me.

Insert the six candles through the six small holes on the top of the cake topper. For now, bend them flat against the plywood.

Next, insert the power switch (add wire length to step) through the 1/4” hole in the plywood. The switch body is on the inside. Attach tightly (use needle nose pliers).

Insert the blue power indicator into one of the 1/4” holes you drilled through the foam ring. Hot glue it in place.

Cut two 6” white wires and get the 9V battery plug. Insert all four wires into the other 1/4” hole in the foam.

Finally, form a loop of bare copper wire a 1/2” to 1” smaller in diameter than the inner foam circle.

Finally, attach the self-adhesive Velcro square to one side of the cake topper bottom. We’ll attach the other half of the Velcro to the Nano later.

Now is the time to get your soldering iron warmed up.

Solder the black wire of the 9V plug to the bare wire.

Solder the black wire of each candle to the bare wire. Note that you can cut this black wire shorter to save some space and make the wiring neater than mine. Just leave some slack to adjust the candles when later attaching them permanently.

Solder the black wire of the power indicator to the bare wire.

Solder one of the white wires, that you fed through the 1/4" hole, to the bare wire.

And finally, solder a short piece of black wire to the bare wire.

The bare wire is our circuit ground. Once all of the above connections are complete, trim off any extra bare wire from the ends of the loop.

Now we are going to wire the power and signal and power connections. When making all of these connections, try to route the wires away from the Velcro. The Velcro is how we’re going to attach the Nano later.

First, solder the red wire from the 9V plug to one terminal of the switch on the cake topper. Cut a 3” piece of red wire and solder it to the other terminal.

The Nano has all of its connection points labeled right on the circuit board. I've provided a picture of the board in this step. As you are reviewing the instructions, look at the picture and note where each one is located.

Now, we are going to physically solder all connections to the Nano. First, the other end of the red wire is soldered to VIN on the Nano. Note that the external connections on the Nano are only 0.1” apart, so don’t use too much solder. Let the iron heat both the wire AND the Nano connection before applying solder. I wait for a three count. Then the solder flows easily onto both surfaces and makes the best joint. The joint should be shiny after it cools and look like the peak of a circus tent.

Now find the other end of that unexplained black wire I had you solder to the circuit ground at the end of the last step. Solder it to the GND connection on the Nano. There are two points labeled GND. It might be easier to use the one on the side of the Nano, away from VIN.

Solder the red wire from the indicator light to D12 on the Nano.

Solder the other white wire to D2.

Now solder the red wires from each candle to the following points on the Nano:

• D3
• D5
• D6
• D9
• D1
• D11

And that's all folks! Firmly attach the other piece of Velcro to the bottom of the Nano, and press it onto the base.

There are three things that need to be done here. Some steps are dependent on your cake, so while describing what I did, I will also describe why I did it.

As I did with the cake topper, I’ll describe placement on the various components as if the cake was a clock face. The back of the cake is at 6 o’clock (hence, the front is 12 o’clock).

First, we’ll install the remaining switch - the control switch. The prop cake was built on a plastic cake stand. Drill a 1/4” hole along the edge at 3 o’clock and install the control switch in the hole. This switch is how the actress in the play lit the candles or blew them out.

At 3 o'clock and 9 o'clock, drill or rasp a 3/8" hole about 1/4" deep. Fill it with hot glue and insert a magnet in each. Try to get it flush with the surface.

Then at 6 o’clock, I drilled through the bottom layer all the way through the stand I had to chuck the bit so the shaft was as long as possible. This step is completely dependent on your cake. If it’s a single layer cake, you may be able to drill a hole from the bottom of the cake stand directly to where the inside of the cake topper would be. The white wires connecting to the Nano wouldn’t have to be routed through the foam ring.

The two white wires were routed from the switch and through the hole. Where the wires entered the new bottom hole, they were sharply bent so they lay flat along the bottom (so that I wouldn't lose them down the hole). Then, the pair of wires were hot glued to the stand. I started at the hole with a generous application of hot glue and tacked the wire with hot glue every couple of inches. The wires must extend above the hole.

Next, let’s modify the top of the cake so we can securely attach the cake topper and the electronics. Cut a couple pieces of 1” sq. scrap paper and put it between the magnets we’ve mounted in the cake topper and a second pair of magnets. They’ll be at 3 and 9 o’clock. This is an important step. Ask me how I know in the comments.

Now, get a little bit of paint (any color) and put a generous coat on the exposed face of each magnet. Flip the cake topper over and hold it above the cake top, about 1/2”. Align everything carefully. The wires coming from the cake topper should be at 6 o’clock and the topper itself should be centered on the cake top.

Then press the cake topper down firmly. We’re trying to mark the magnet locations!

Lift the topper off and set it aside after wiping the paint from the magnets. Then, drill out the magnet locations. Use a 3/8” drill and go down about 1/4”. Or use a rasp bit in the motor tool. Fill (yes, I said “fill”) both holes with hot glue. Then press the cake topper back on top, ensuring the magnets become embedded in the hot glue. Leave it alone for a while.

Next, I had to connect the white control wires and hide the battery wires. I used a cutoff wheel in the motor tool.

The wires exiting from the cake topper SHOULD exit directly above the hole we drilled earlier for the white wires from the control switch. With the motor tool, cut through the cake “frosting”, to create a channel for the wires.

Then, trace a 9V battery, starting with one edge along the channel you just cut. Peel off the frosting, and with the rasp bit, hollow out a space for the battery. Make several shallow cuts, test fitting the battery, until it fits a little lower than the frosting. Then, make a 3/8” hole for another magnet. Fill the hole with hot glue, cover with a scrap of paper and insert the 9V battery to hold the magnet in place until the glue cools. (The scrap of paper prevents the hot glue from squeezing out of the hole and adhering to the battery. It’s why we did the same thing earlier in this step)

The magnet holds the battery in place. Now, the battery in a hole looks out of place in the side of a cake. So, I cut a rectangle from white poster board to cover the hole. Hot glue the last magnet to this piece. Curve the poster board slightly and use it to cover the battery hole.

Having described this step, I had decided to mount the battery on the outside before I decided how to attach the cake topper. I did it this way so that it was easy to change the battery.

But after I mounted the cake topper with magnets as well, I realized that I could have placed the battery inside the cake topper. That would still allow the battery to be changed easily, simplify the battery wiring and eliminate carving a hole on the outside of the cake.

So, for a single layer cake you can route the white wires directly to the Nano and you can also hide the battery in the cake topper,. This simplifies things a bit; you don’t need to do the last couple of things.

Just saying!

Finally, solder the pairs of white wires together. On at least one pair, slide on a piece of small diameter heat shrink tubing. The only critical measurement is that the tubing must fit over the soldered connection. Heat it to insulate the joint. (I have a New England Patriots lighter for this in my toolbox) When soldered, push them (and the battery wires) into the channel. Force any slack of the white wires into the hole. Then with hot glue, attach the wires at the hole and fill the channel with hot glue.

You should have everything assembled by this point. Now, let’s program the Nano to simulate the candles burning and being blown out!

A short (relatively) Arduino sketch runs in the Nano to simulate flickering candles and also simulate blowing out said candles. The Arduino language is a variant of the C language. Arduino sketches impose a structure, which I’ll provide a detailed description in the following steps.

There is a ton of tutorials available, including sample sketches for each feature. Familiarize yourself with the official web site, arduino.cc, and you’ll be up and running in short order.

Regarding the sketch structure, here’s a quick introduction.

Generally, you need to define all of your variables.

Then, there is a setup function where you initialize any peripherals (in this code, peripherals mean the input and outputs - the candles).

The next part of an Arduino sketch is the main loop. This loop has an interesting property; once the code inside finishes, it automatically starts over again. Also, you can define your own functions. I’ve done this a couple of times, and I’ll explain why.

The complete Arduino sketch is attached as a text file to this step.

But enough! Let’s look at the Candles sketch in detail!

Note that there are several ways of defining common values. I define “runPin” as PIN number 12. I could have defined it this way:

const int runPin=12;

But I used this instead:

#define runPin 12

“#define” is like a global search and replace. It looks through my sketch for all occurrences of “runPin” and replaces it with 12. This is called a macro and can be very useful. I often include in my sketches

#define Halt while(-1)

Then, if something go goes wrong, I add one line, “Halt;”, and the Arduino doesn’t do anything until it’s reset.

Here are some of the definitions I included in the Candle sketch:

All of the PIN numbers used by the sketch.

• analogPin - used in a common Arduino trick to ‘scramble’ the random function to get really random numbers.
• runPin - the output pin used to indicate that the Nano is powered on and running. Otherwise, if the candles are flickering, the actress can’t tell if they are running, the battery is dead or someone turned off the power. Imagine her chagrin if she’s on stage, lights the candles in front of the audience AND NOTHING HAPPENS!
• SwitchPin - this is an input pin, with which the actress lights or blows out the candles

Next is a series of definitions for the operation of the sketch. They really aren’t necessary, but I include them so I can modify the effect without having to search through my code. By defining some of the numbers here, I avoid the inevitable grief if I were to search for everywhere that they are used, forget one and pull my hair out when the program doesn’t work. Examples of these definitions are:

• minFlame – lowest brightness allowed for the candle flame
• myPause - delay between candle ‘flickers’. This value was experimentally chosen.
• levelChange - amount to change when blowing out the candles
• ON - just used to make the code more readable

I think the comments included on each definition are sufficient, so I won’t describe them all.

And the last definition here, is the list of pins to which the candles are attached.

byte LEDPIN[] = { 3, 5, 6, 9, 11, 10}; // For Nano

There is one other place where variables are defined. In the main loop. These are variables which are ‘local’ to the main code in the loop() function. ‘Local’ means that they are not referenced elsewhere. In this section, we have:

• Level[] - an array used to save the current brightness (or level) of each candle
• candle, repeat and i are variables used to index various arrays or operations.
• Lit - a Boolean or logical value that is true if the candles are lit; false otherwise

These will make more sense when reviewing the actual code.

First, there is a call to a function called randomSeed(). When given a value that changes each time the sketch is run, called a “seed”, the random numbers returned by the random() function will be different. A common way to get this number on an Arduino is to read the analog voltage on an unconnected pin. Since this pin isn’t connected to anything, it will essentially be a random value.

The main task we need to accomplish during setup, is that we have to do is initialize the all pins used. There are three different types of pins we use in the sketch.

• runPin - the status LED
• switchPin - determines when we light/blow out the candles
• LEDPIN[] - the pins for the candles

The first two pins are initialized to be inputs. The pins for the candles are listed in the LEDPIN[] array. Each pin is initialized in a for loop and set to an output. I also set each pin to be off initially, by using the analogWrite() function.

A word on the analogWrite() function. We change the brightness of the LEDs by a technique call Pulse Width Modulation (PWM). Instead of setting the voltage to 0 or +5 volts, PWM turns the voltage on and off for a variable amount of time by sending a series of voltage pulses and varying how long that pulse is on. The range of values that the PWM functions is 0-255. Off is 0; full on is 255. So, for full brightness, the pulse is on all the time. For creating a brightness halfway between full on or off, the pulse is on for only half the time. In the main loop, we’ll use this feature and the random() function to make the candles flicker.

First we blink the LED to indicate that the sketch is running for the actors/actresses. That's what the showStatus() function is included.

Then, we check to see if the control switch is set to light the candles. The if statement uses a Boolean function Ive written to determine the status of this switch and if its requesting that the candles be lit. This function is extremely simple and totally unnecessary, but it helps when reading the sketch. Here is the function:

<p>// ==================================
boolean candlesLit()
{
  return (digitalRead(pinSwitch) == ON);</p><p>}</p>

Now, which is easier to understand?

  if (candlesLit()) {

or

  if(digitalRead(pinSwitch) == ON) {

So, the following code will only be executed when we want the candles to be lit. To light the candles, we perform a simple loop through the array containing the pin numbers for each candle. As the comment indicates, there are six candles. For each candle, there are three steps:

<p>level[candle] = random(minFlame, 255); // flicker is chosen randomly<br>      analogWrite(LEDPIN[candle], level[candle]);
      delay(myPause); // pause a bit at each level</p>

1. We calculate a random brightness value. We’ve defined a minimum value, so the candle doesn’t get stuck in a low brightness.
2. Then, we set each candle’s brightness to the value calculated. We save this in an array, so we can use the last brightness level when blowing out the candle.
3. Finally, we pause a bit. This gives the audience a chance to perceive the brightness change.

We continue to do this until the actress toggles the control switch. Otherwise, it’s lather, rinse, repeat!

The code to blow out the candles is more complex. First, there is a requirement that the code be executed only once, whereas the candle flickering code was meant to execute many times. To accomplish, there is a Boolean variable that tells us that the candle is already lit. Unimaginatively, I named this variable "Lit". The Light/Flicker code sets this variable to be true, each time it is executed. This code checks the control switch signal AND whether or not the candles are lit. Then, and only then, it blows out the candles. And since the code is blowing the candles out, the first thing it does is set the Lit variable to be false. Correspondingly, once the candle light code executes, the "Lit" variable is set to be true.

I could have chosen just to turn off all the candles, but since they were flickering, I wanted to blow them out more slowly. So, there are a couple of differences. I added an outer loop to simulate a number of puffs. Each puff dims the candle a little bit more than the last iteration.

I then loop through all the candles. The code in this second loop is based on the code to light/flicker the candles. The biggest change is how I calculate the new brightness. I first substract a constant bit from the last level (“levelchange”) and then make sure I haven’t gone out of bounds for the analogWrite() function, which is used to show the candle brightness. Arduino has a simple function to do this, constrain(value,minimum,maximum). This returns the minimum acceptable value is the value is less than the minimum. Do you want to guess what happens if the value is greater than the maximum acceptable value?

Then, there is the delay statement we had before… Wait! There’s something else!?! When we started this code, the candles were not lit. But if we’re blowing the candles out and the actress toggles the switch to light the candles, we gotta stop blowing the candles out. There are several of these at the end of various loops. They look like

<p>if (candlesLit()) break</p>

That says, if the switch has been toggled, break out of this loop immediately.

Finally, there is one more loop through the candles, to make sure they are all turned off.

Behind The Scenes: The code I presented in the step is NOT my original code. The action was much more involved. When an actor blew out the candles, they dimmed out in groups. First, the candle closest to the actor, Them the next two and the next two candles went out. This left one recalcitrant candle that almost went out, flared up and finally was extinguished with one last blow. This proved to be neat, but too complicated for the production. And it would NOT have been fun to describe. I’ll just say that this level of detail in possible and was coded with multiple loops embedded within loop, each one for a specific part of the pattern.

There are a couple more code bits, I want to explain. This function, showStatus(), is used to blink an LED on the outside of the cake. Without any such indicator, the actors and actresses wouldn’t know if the cake was functional. They’d be on stage, toggle the control switch – AND – nothing would happen.

One last line of code. This is decribed on the main section of code, and is used to indicate if the candles or lit or if they are off. As I mentioned in the other description, its existence is purely for code readability and as an example in this Instructable.

At the beginning of the sketch, is a simple line that says: showStatus();This flashes the status LED. It may be weird that it's called only once, but thats a feature of the Arduino. When the microprocessor is started or reset, the setup code is executed once. The code in the loop function acts like it is an infinite loop, executing over and over again.

There are three variables defined locally. Two are static, which means that their values are maintained between function calls. “updateTime” is the number of milliseconds in the future that the LED goes from off to on to off to on… If the current time, “millis()”, is greater that the saved value in updateTime, we toggle the value of ledState. nextState is used only in this calculation.

Effectively this code blinks an LED hidden in the outside of the cake. On for ½ second, off for ½ second until the power is shut off.

<p>void showStatus()<br>{
  static unsigned long updateTime = 0;
  static unsigned int ledState = HIGH;
  int nextState = LOW;
  if (millis() >= updateTime) {
    if (ledState == HIGH) nextState = LOW;
    if (ledState == LOW) nextState = HIGH;
    ledState = nextState;
    digitalWrite(runPin, ledState);
    updateTime = updateTime + 500;
  }
}</p>

One last line of code. This is described in the main section of code, and is used to indicate if the candles or lit or if they are off. As I mentioned in the other description, its existence is purely for code readability and as an example in this Instructable.

<p>boolean candlesLit()<br>{
  return (digitalRead(pinSwitch) == ON);
}</p>

The prop cake I was modifying was originally a two-layer wedding cake. It consisted of two stacked Styrofoam cylinders. It had been coated with a thin layer of plaster and decorated with what appears to have been caulking compound applied with a cake decorating bag. The top used to have a plastic bride & groom topper, which had been ripped off leaving holes in the plaster.

My first problem that my new cake top had none of the decorations along its outer edge that was on the rest of the cake. Not being a cake decorator, I had to find something that would like the existing decorations from a distance. To remedy this, I used the caulking gun to lay a bead of project adhesive along the outer edge. Then, I placed small pasta shells in the adhesive.

Next, I painted the plywood, foam ring, switches, wiring channel and anything else that was not white, with white paint. And let it dry.

Then, I painted the shells and decorations on the edges of the cake a brick red color (it matched the color of the candles). And let it dry. Note that there were also decorations on the cake sides. I said to myself, “They scream wedding cake...”. So, I left them white.

Finally, I purchased multi-colored decorating sprinkles and a $0.99 bottle of white glue. I used a 1” brush and liberally applied a coat of white glue. Then, I also liberally applied the sprinkles. After the glue had dried thoroughly, I sealed the sprinkles with a gloss spray sealant.

And what was a damaged wedding cake is now a birthday cake!

There is a lot of information in this Instructable. I hope that some of you will take away some gem or another. Something you can use.

The sketch (Arduino-speak for ‘program’) is a little complex. Lighting the candles to look like they’re flickering is simple. Blowing them out is more complex, but demonstrates that any sequence is possible.

But as I said, there’s a lot covered; even more that coding.

There’s a bit of programming plus there’s using an Arduino Nano. Making a birthday cake prop. Using magnets to attach details... Hiding wires for electronics in a prop, cosplay costume or Halloween. Let me know what YOU found useful. My show has closed. I hope my prop added to the audience’s enjoyment. And I hope it adds to your's as well!