The Party Machine
Music, lights, and bubbles at your fingertips
Project Website: https://aansari0.wixsite.com/partymachine
Skills and Tools
Physical Computing | Prototyping | Soldering | Arduino Programming | XCTU
Melody Xu and Chue Yang developed the controller glove
Mike Eacker and Lauren Beehler created the Bubble Maker component
Aleenah Ansari and Jacqueline Yu worked on the command center of the system
Click on Icons to see Documentation
System Diagram that shows the relationship between each component of the glove
Drawing of my initial concept, including designing input and output of the controller
Initial Idea Sketches
The LCD is replaced with LEDs and position of sensors is modified. We also decided to use fixed gestures (such as moving the hand up and down) instead of rotating the hand to control the movement of the bubble maker.
We used the Fritzing application to show the electronic circuit.
Wiring design of our final component
We had difficulty in controlling the sensors and getting consistent, reliable data. Most of our time was spent on testing sensors and calibrating them to get the desired values. Having a slightly different positioning of the flex sensor and accelerometer would sometimes invalidate the data collected. We have to be extremely careful with the sensors. Flex sensors were sensitive to movement of the fingers or movement of the gloves. When the they were sewn onto the gloves, certain parts buggle up (due to different finger lengths and the knuckle location). Over time, with constant testing and transporting them around, one of the flex sensors broke at the base. Luckily, we had a few spare flex sensors and was able to replace, re-solder and resew the broken flex sensor back on the glove.
Even though the accelerometer was working, it was also sensitive and noisy that we had to tweak the code multiple times to ensure that it was working consistently. To reduce the noise, we wrote code that would only return an average acceleration value over multiple interval points (20) and over a period of time (1 second). In order to get a consistent value for capturing a specific gesture, we decided to detect gesture by capturing a huge change in one axis. Initially, we had code to detect four different types of gestures: moving the accelerometer “left and right”, “back and forth”, “in a circle”, and “up and down”. However, we ended up only using one gesture to reduce the engineering demands on another part of the project.
Issues with Buttons
We had a problem of detecting button clicks. The user sometimes has to click the buttons multiple times before getting a response. We believe that this is due to the delay in the loop section of our program. The loop section contains/calls many lines of code, and delays naturally as the program processes the code. This resulted in increasing the time interval before checking for clicks, which leaves clicks often go undetected. We didn’t use the button library for this project because we thought having additional button gestures (such as press hold) was unnecessary. However, using the button library could have been helpful for detecting when a click happens.
Adjustment from Arduino Uno to Adafruit Feather
When designing the controller glove, we had a goal of making the remote controller as small as possible. At first, we focused on testing with the basic Arduino Uno, but we were unsatisfied with its size. The Arduino Uno did not fit nicely with the glove, and the wires were hard to manage. With multiple testings and adjustments, we were able to switch from the Arduino Uno to the more compact Adafruit Feather, which also made organizing wires easier and prevented them from slipping and falling off the breadboard. At last, our delicate physical product, being the lightest and smallest remote controller in the class, performed perfectly with everything connected securely. With its own 3.3V battery, the glove controller was on its own, travelled freely with the hand.
As a whole, this project was a valuable experience for us to design and build a product of our own interest, learn about physical computing, participate in a team and collaborate with people with different experiences. Communication was crucial to the team’s overall success, as we all had to constantly check in and help each other to move forward in the project. It was common for us to adjust our parts of the code to accommodate what the other teams needed. There were also stressful times when we were frustrated because we couldn’t figure out why something wasn’t working, and we had to stay up debugging and modifying the code for hours. Looking back, all the hard work did not waste. Seeing our demo working on presentation day was exciting and extremly rewarding.
Additionally, we really enjoyed seeing what other student groups came up. We’re glad that other people thought that our idea was unique and offered a fun experience for anyone who likes bubbles, lights, and music.
Links that helped us with this project
The Party Machine is a total party system for the bubble enthusiast. The system consists of three main components: bubble maker, controller, and command center. First, the bubble maker houses two bubble guns mounted to a rotating turret. Additionally, the bubble maker creates lighting effects that reflect onto the outgoing bubbles as they flow from the enclosure. Next, the controller, which is built into a glove, is used to manipulate the output of bubbles in the bubble maker. By flexing the fingers of the glove, the controller can regulate the output of bubbles. Furthermore, the glove has the ability to rotate the turret (housed within the bubble maker) to change the direction in which bubbles flow. Finally, the command center is the brain of system. The command collects and displays messages and status updates from the bubble maker and controller and creates music to add to the party atmosphere of the system.
by Melody Xu and Chue Yang
The glove controller is composed of a 6V battery, buttons, LED lights, flex sensors, an XBee, and an accelerometer. The flex sensor controls the amount of bubbles produced by the bubble maker and the accelerometer detects gestures that control the bubble maker's movements. The LED lights act as actuators to show change in sensor values. Buttons are used to turn on/off LED lights and stop the bubble maker's movements. The glove sends data through the XBee to both the command center and the bubble maker.
Here is a simple block diagram of my project that illustrates the major hardware components of the system and how they are interfaced to the Arduino.
Implementation: How the Glove Works
By pushing one of the buttons, the controller would turn on/off LEDs on the glove. Having the light indicator would also give us feedback that our code and our button are both working. The LEDs are also used to signal a change in the flex sensors and if data is sent through the XBee. When we flex our fingers, the the flex sensor send send a flex value (0 = no bubbles, 1 = one bubble gun, 2 = two bubble guns) to control the amount of bubbles being produced. The more the finger flexes, the more bubbles would be generated. We utilized the accelerometer to detect change in hand movement (such as moving the hand up and down). If there is enough change in one direction, we would send a message to the Bubble Maker, causing the bubble maker to rotate (or jitter). In addition, we implemented a button that sends commands to stop the jitter motion of the bubble maker.
Software: Design and Approach
Our approach for creating the remote controller was to test out each component prior to integrating all the parts together. We started with letting each part having its own code. This allowed us to test parts separately at any time during the development phase to ensure that each part is working correctly, which helped with debugging. For example, we wrote the codes for the flex sensors and the accelerometer separately and tested both of these codes separately before integrating them. After integrating, we often had problems with the sensors and had to come back to the original codes for detecting abnormalities. After making sure that the two major components are working correctly together, we added buttons, LED lights, and the XBee. Once all parts were integrated, we started thinking about the physical design of our project. Since we planned on having a wearable, it was important to us that the controller would be clean and compact. We decided to switch the Arduino Uno for an Adafruit Feather microcontroller for a smaller size and easier movement.
Sending Messages to the Command Center and Bubble Maker:
To communicate with other stations, we are sending the following messages through the Xbee.
Note: "id:bc” is the identification for this remote site, so other sites would know that the command is coming from the controller glove. The code after the "|" indicates what kind of data is being transmitted, followed by its value.
"id:bc|bubMode:0" // No Bubbles
"id:bc|bubMode:1" // One bubble gun makes bubbles
"id:bc|bubMode:2" // Two bubble guns make bubbles
“id:bc|gestMode:0” // Bubble maker stops moving
“id:bc|gestMode:1” // Bubble maker moves (Jitterbug Mode)
Click for Controller Code