Description of Final Assembly
The completed project is just as described before. We have a 3X3X3 LED cube wired into a PCB with an acrylic casing covering the whole assembly. This cube then sits on top of a motion mechanism. This mechanism consists of one small servo motor mounted on top of a bigger servo. Using the 3D printer parts were fabricated for this mechanism. Manufactured parts included two servo casings, a bracket, and a platform. In addition to these printed part there were five sides to the LED cube that were laser cut out of acrylic. As for inputs into the whole system there were two potentiometers and one microphone. Each of the potentiometers controlled on of the servo motors. The microphone was used to control the LED cube. Sounds that the microphone picked up triggered a certain pattern based on the volume.
Overall the project did what we set out to do. LED lights were controlled by a microphone, with motion provided by the servos.During transportation to the showcase the 'platform' part broke and was unable to be fitted back to the small servo. Because of this we couldn't fully test the motion of the cube. The following is a picture of the completed assembly:
Below are the final versions of the code used. One for LED control the other for servo control
Improvements
With this being the first design iteration there are many improvements that could be made. The following is a list of things that could be better developed.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| #include <Servo.h> | |
| Servo myservo; // create servo object to control a servo | |
| Servo myservo1; // create servo object to control a servo | |
| int potpin = 0; // analog pin used to connect the potentiometer | |
| int potpin1 = 1; // analog pin used to connect the potentiometer | |
| int val; // variable to read the value from the analog pin | |
| int valu; | |
| void setup() | |
| { | |
| myservo.attach(9); // SMALL attaches the servo on pin 9 to the servo object | |
| myservo1.attach(10); // BIG attaches the servo on pin 10 to the servo object | |
| } | |
| void loop() | |
| { | |
| val = analogRead(potpin); // reads the value of the potentiometer (value between 0 and 1023) | |
| valu = analogRead(potpin1); // reads the value of the potentiometer (value between 0 and 1023) | |
| val = map(val, 0, 1023, 0, 179); | |
| valu = map(valu, 0, 1023, 0, 179); // scale it to use it with the servo (value between 0 and 180) | |
| myservo.write(val); // sets the servo position according to the scaled value | |
| myservo1.write(valu); // sets the servo position according to the scaled value | |
| delay(15); // waits for the servo to get there | |
| } |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| // 22.201 | |
| // Code for controlling LED cube with microphone | |
| // ******************************* | |
| // MIC | |
| const int ledPin = 12; //the code will flash the LED in pin 12 | |
| const int middleValue = 512; //the middle of the range of analog values | |
| const int numberOfSamples = 128; //how many readings will be taken each time | |
| int sample; //the value read from microphone each time | |
| long signal; //the reading once you have removed DC offset | |
| long averageReading; //the average of that loop of readings | |
| long runningAverage=0; //the running average of calculated values | |
| const int averagedOver= 16; //how quickly new values affect running average | |
| //bigger numbers mean slower | |
| const int threshold=400; | |
| // ********************************** | |
| // Row control | |
| int ledRow1 = 13; //Row 1 | |
| int ledRow2 = 12; //Row 2 | |
| int ledRow3 = 11; //Row 3 | |
| //Cols 1,2,3 + Rows can control LEDS 1-9 | |
| int ledCol1 = 9; | |
| int ledCol2 = 8; | |
| int ledCol3 = 7; | |
| //Cols 4,5,6 + Rows can control LEDS 10-12 | |
| int ledCol4 = 6; | |
| int ledCol5 = 5; | |
| int ledCol6 = 4; | |
| //Cols 4,5,6 + Rows can control LEDS 10-12 | |
| int ledCol7 = 3; | |
| int ledCol8 = 2; | |
| int ledCol9 = 1; | |
| //define the LED cube size | |
| int rowmax = 3; | |
| int colmax = 9; | |
| //making an array | |
| int ledCol[9]; | |
| int ledRow[3]; | |
| // the setup routine runs once when you press reset: | |
| void setup() { | |
| //*************************** | |
| // Microphone Setup | |
| Serial.begin(9600); | |
| //***************************** | |
| //used for random value | |
| //Serial.begin(9600); | |
| // initialize the digital pin as an output. | |
| //3 rows | |
| pinMode(ledRow1, OUTPUT); //Top | |
| pinMode(ledRow2, OUTPUT); //Middle | |
| pinMode(ledRow3, OUTPUT); //Bottom | |
| //9 Columns | |
| pinMode(ledCol1, OUTPUT); //Left | |
| pinMode(ledCol2, OUTPUT); //Middle | |
| pinMode(ledCol3, OUTPUT); //Right | |
| pinMode(ledCol4, OUTPUT); //Left | |
| pinMode(ledCol5, OUTPUT); //Middle | |
| pinMode(ledCol6, OUTPUT); //Right | |
| pinMode(ledCol7, OUTPUT); //Left | |
| pinMode(ledCol8, OUTPUT); //Middle | |
| pinMode(ledCol9, OUTPUT); //Right | |
| //fill array | |
| ledCol[0] = ledCol1; | |
| ledCol[1] = ledCol2; | |
| ledCol[2] = ledCol3; | |
| ledCol[3] = ledCol4; | |
| ledCol[4] = ledCol5; | |
| ledCol[5] = ledCol6; | |
| ledCol[6] = ledCol7; | |
| ledCol[7] = ledCol8; | |
| ledCol[8] = ledCol9; | |
| ledRow[0] = ledRow1; | |
| ledRow[1] = ledRow2; | |
| ledRow[2] = ledRow3; | |
| } | |
| void loop() { | |
| //*************************** | |
| // MIC | |
| long sumOfSquares = 0; | |
| for (int i=0; i<numberOfSamples; i++) { //take many readings and average them | |
| sample = analogRead(0); //take a reading | |
| signal = (sample - middleValue); //work out its offset from the center | |
| signal *= signal; //square it to make all values positive | |
| sumOfSquares += signal; //add to the total | |
| } | |
| averageReading = sumOfSquares/numberOfSamples; //calculate running average | |
| runningAverage=(((averagedOver-1)*runningAverage)+averageReading)/averagedOver; | |
| Serial.println(runningAverage); | |
| //**************************************** | |
| // PATTERN CODE | |
| delay(100); | |
| if ((runningAverage>1500) && (runningAverage <2000)) | |
| { | |
| rainLight(); | |
| } | |
| delay (100); | |
| if ((runningAverage>2000) && (runningAverage <2500)) | |
| { | |
| lightning(); | |
| } | |
| delay (100); | |
| //rainMed(); | |
| //delay (2000); | |
| //lightning(); | |
| delay (100); | |
| if (runningAverage > 2500) | |
| { | |
| rainHeavy(); | |
| } | |
| } | |
| // ************************************************ | |
| // FUNCTIONS FOR ALL PATTERNS | |
| // FUNCTIONS!!!!! | |
| //All helper functions used to create designs and patters throughout the loop | |
| //LED movements | |
| //flashes both top and bottom panes | |
| void lightning(){ | |
| topPaneOn(); | |
| bottomPaneOn(); | |
| delay(25); | |
| topPaneOff(); | |
| bottomPaneOff(); | |
| delay(100); | |
| topPaneOn(); | |
| bottomPaneOn(); | |
| delay(25); | |
| topPaneOff(); | |
| bottomPaneOff(); | |
| topPaneOn(); | |
| bottomPaneOn(); | |
| delay(25); | |
| topPaneOff(); | |
| bottomPaneOff(); | |
| delay(100); | |
| } | |
| //animate | |
| //Heavy rain | |
| void rainHeavy(){ | |
| int del = 80; | |
| int del2 = 60; | |
| randomSeed(analogRead(0)%10); | |
| //Serial.println("Analog input"); //testing | |
| //Serial.println(analogRead(0)%10); //testing | |
| for(int x= 0; x<50; x++){ | |
| int stCol = random(0,colmax); | |
| int stCol2 = random(0,colmax); | |
| int stCol3 = random(0,colmax); | |
| int stCol4 = random(0,colmax); | |
| int dropNum = random(0,9); | |
| //Serial.println(dropNum); //testing | |
| for(int y=rowmax-1;y>-1;y--){ | |
| if(y==rowmax-1) del2 = 80; //if first row | |
| onLED(ledRow[y], ledCol[stCol]); | |
| if(dropNum>=4){ | |
| onLED(ledRow[y], ledCol[stCol2]); | |
| } | |
| if(dropNum>=7){ | |
| onLED(ledRow[y], ledCol[stCol3]); | |
| } | |
| if(dropNum>=8){ | |
| onLED(ledRow[y], ledCol[stCol4]); | |
| } | |
| delay(del2); | |
| //turn off all even if they wern't turned on. | |
| offLED(ledRow[y], ledCol[stCol]); | |
| offLED(ledRow[y], ledCol[stCol2]); | |
| offLED(ledRow[y], ledCol[stCol3]); | |
| offLED(ledRow[y], ledCol[stCol4]); | |
| del2=30; | |
| } | |
| delay(del); | |
| } | |
| } | |
| //animate | |
| //light rain | |
| void rainLight(){ | |
| int del = 170; | |
| int del2 = 70; | |
| for(int x= 0; x<20; x++){ | |
| int stCol = random(0,colmax); | |
| for(int y=rowmax-1;y>-1;y--){ | |
| if(y==rowmax-1) del2 = 110; | |
| onLED(ledRow[y], ledCol[stCol]); | |
| delay(del2); | |
| offLED(ledRow[y], ledCol[stCol]); | |
| del2=70; | |
| } | |
| delay(del); | |
| } | |
| } | |
| //static | |
| void topPaneOn(){ | |
| digitalWrite(ledRow1, HIGH); | |
| digitalWrite(ledCol1, HIGH); | |
| digitalWrite(ledCol2, HIGH); | |
| digitalWrite(ledCol3, HIGH); | |
| digitalWrite(ledCol4, HIGH); | |
| digitalWrite(ledCol5, HIGH); | |
| digitalWrite(ledCol6, HIGH); | |
| digitalWrite(ledCol7, HIGH); | |
| digitalWrite(ledCol8, HIGH); | |
| digitalWrite(ledCol9, HIGH); | |
| } | |
| void topPaneOff(){ | |
| digitalWrite(ledRow1, LOW); | |
| digitalWrite(ledCol1, LOW); | |
| digitalWrite(ledCol2, LOW); | |
| digitalWrite(ledCol3, LOW); | |
| digitalWrite(ledCol4, LOW); | |
| digitalWrite(ledCol5, LOW); | |
| digitalWrite(ledCol6, LOW); | |
| digitalWrite(ledCol7, LOW); | |
| digitalWrite(ledCol8, LOW); | |
| digitalWrite(ledCol9, LOW); | |
| } | |
| /* | |
| //static | |
| void middleTBPaneOn(){ | |
| digitalWrite(ledRow2, HIGH); | |
| digitalWrite(ledCol1, HIGH); | |
| digitalWrite(ledCol2, HIGH); | |
| digitalWrite(ledCol3, HIGH); | |
| digitalWrite(ledCol4, HIGH); | |
| digitalWrite(ledCol5, HIGH); | |
| digitalWrite(ledCol6, HIGH); | |
| digitalWrite(ledCol7, HIGH); | |
| digitalWrite(ledCol8, HIGH); | |
| digitalWrite(ledCol9, HIGH); | |
| } | |
| void middleTBPaneOff(){ | |
| digitalWrite(ledRow2, LOW); | |
| digitalWrite(ledCol1, LOW); | |
| digitalWrite(ledCol2, LOW); | |
| digitalWrite(ledCol3, LOW); | |
| digitalWrite(ledCol4, LOW); | |
| digitalWrite(ledCol5, LOW); | |
| digitalWrite(ledCol6, LOW); | |
| digitalWrite(ledCol7, LOW); | |
| digitalWrite(ledCol8, LOW); | |
| digitalWrite(ledCol9, LOW); | |
| } | |
| */ | |
| void bottomPaneOn(){ | |
| digitalWrite(ledRow3, HIGH); | |
| digitalWrite(ledCol1, HIGH); | |
| digitalWrite(ledCol2, HIGH); | |
| digitalWrite(ledCol3, HIGH); | |
| digitalWrite(ledCol4, HIGH); | |
| digitalWrite(ledCol5, HIGH); | |
| digitalWrite(ledCol6, HIGH); | |
| digitalWrite(ledCol7, HIGH); | |
| digitalWrite(ledCol8, HIGH); | |
| digitalWrite(ledCol9, HIGH); | |
| } | |
| void bottomPaneOff(){ | |
| digitalWrite(ledRow3, LOW); | |
| digitalWrite(ledCol1, LOW); | |
| digitalWrite(ledCol2, LOW); | |
| digitalWrite(ledCol3, LOW); | |
| digitalWrite(ledCol4, LOW); | |
| digitalWrite(ledCol5, LOW); | |
| digitalWrite(ledCol6, LOW); | |
| digitalWrite(ledCol7, LOW); | |
| digitalWrite(ledCol8, LOW); | |
| digitalWrite(ledCol9, LOW); | |
| } | |
| //turn on LED based on row number and column number | |
| void onLED(int row, int col){ | |
| digitalWrite(row, HIGH); //turn on row | |
| digitalWrite(col, HIGH); //turn on col | |
| } | |
| //overload funtion - used to turn LED on with certain intensity | |
| void onLED(int row, int col, int value){ | |
| digitalWrite(row, HIGH); //turn on row | |
| analogWrite(col, value); //turn on col | |
| } | |
| //turn off LED based on row number and column number | |
| void offLED(int row, int col){ | |
| digitalWrite(row, LOW); //turn on row | |
| digitalWrite(col, LOW); //turn on col | |
| } | |
With this being the first design iteration there are many improvements that could be made. The following is a list of things that could be better developed.
- Write in a break statement into the LED pattern code so every time the value of the microphone changes the code breaks out of its current pattern and starts a new one. This will give a more responsive LED cube.
- Code the microphone to read the music being played not only the volume. The microphone would read the music frequency band spectrum. This way the LED cube could react to the type of music being played. Things like tempo and pitch would be a factor in LED display.
- Upgrade the second level small servo to a bigger one to provide more motion.
- Refine the whole motion mechanism. Currently it is very primitive with just the servos stacked on top of one another. Create better solid models that fit together. The thickness of the extrude needs to be increased to be stronger on the 'platform' 3D printed part.
- Write code for the microphone so it calibrates itself upon start up. This would calibrate it with the surrounding environment. Within the first 5 seconds the microphone would take the lowest and highest values and used those as threshold values to run the LED patterns.
- Better assembly of the LED cube. Use longer more flexible wires; use a coupling to organize all the wires underneath the cube. Have holes in the acrylic cube for the wires.
- Replace all the red and yellow LEDs with RGB LEDs for a more colorful performance.
- Map microphone data to control both servos. This would give a completely self-sufficient system, instead of having user input control.
Jennifer Droke:
- Design of acrylic cube casing. Created SolidWorks models for a visual of the final assembly, as well as for having the part made.
- Designed wiring layout for LED cube based on tutorial http://randomnerdtutorials.com/arduino-led-cube-3x3x3/
- Assembled, soldered, and tested LED Cube
- Assembled acrylic casing from cut parts
- Soldered wiring on PCB
- Purchased the proper transistors, resistors, jumper wires, PCB, and microphone for the cube, as well as materials for the project board and the potentiometers for the servo motors
- Assembled final prototype for presentation
- Created tri-fold project board and researched/typed information for presentation
- Wrote about four blog posts, contributed to one other. Made multiple pictures and videos for blog.
- Estimation of total hours worked: 35 hours
My thoughts: Our group worked together very well, and we all contributed equally. Every meeting, we were all deep in work and maintained open communication. If anyone missed a meeting, the work was quickly and easily made up with all the hours put in at home. It was great working with two exceptional team members who worked to make our final prototype work just as we wanted it to in our original idea.
Matthew Popelka:
- Design of the motion mechanism using the servos. Created all necessary solid models on SolidWorks.Converted to STL file type and checked part material. Then redesigned accordingly to reduce material cost and manufacturing time.
- Purchased bigger servo to ensure smooth motion of LED cube.
- Modified/integrated the microphone code with the LED control code. Debugged code so patterns would display with correct threshold levels.
- Wrote about 6 blog spots
- Edited/finished final report
- Estimation of total hours worked: 35 hours
My thoughts: I believe everyone contributed fairly and pulled their own weight, we worked well as team. During the team meetings we were all researching, wiring circuits, and discussing. I will say that Jen had the harder task of soldering, wiring, and assembling the LED cube and should be credited accordingly.
Samir Meskinaoui:
- Wrote and modified code for the two servo. Harness Arduino component like the potentiometer to control the motion of two servos.
- Estimation of total hours worked: 35 hours
- Edited/started final report.
- Wrote about 3 blog spots.
- Search for Arduino codes for the both the servos and microphone and checking all circuits.
My thoughts: I have worked in many groups in my college career. For the first time, I felt like the group was fair and everyone pulled their weight equally. We all enjoyed creating and learning the new material. Jenn did an excellent job of assembling the LEDs.
