3D Printing expo

The 3D printing conference was a pretty interesting experience. From the moment I walked in I heard nothing but questions and explanations as to regarding the strength of the builds, price of the printers or services, and what the builds were made from. I think my favorite printer there would have to be the one from Mcor Technologies because of its use of paper instead of filament, I overheard the representative say that by using paper each build came out as strong as wood, I managed to speak to one representative and he actually asked me questions as to what I knew about 3D printing as well as my interests in it. My favorite was probably this, it seemed so cool because the entire thing is one solid print with no pieces needing assembly.
I do like comics:
Displaying photo 1.JPG
Displaying photo 2.JPG
I SUCK at selfies:
Displaying photo 3.JPG

Final Project: Sound Mirror

     The initial idea for this project was to create a piece of reactive furniture using the Arduino as in this video of a table that reacts to objects being placed on it. It wasn’t until i witnessed someone scream at a mirror because they were frustrated with their appearance that I thought of creating a reactive mirror. In the process of assembling this I considered different audiences that could put this idea to use, by doubling as a mirror and VU-meter it can be used as a conversation piece at home, an art piece, or simply a decoration on someone’s desk.
     Many people were inquisitive in regard to the purpose of this project as well as the story behind it, after explaining that the concealed microphone is sensitive enough to pick up sound from several feet away one woman yelled directly at it while others snapped their fingers next to it and watched as the mirror indicated how many decibels were being picked up as indicated by the internal LEDs which were each attached to a different pin on the Arduino, each pin programmed to react to a different set of values. Not everyone knew how to interact with it at first but as the hidden microphone reacted to loud background noise they pieced it together and began playing with it. I was actually surprised by how many people approached it and asked me about it considering its simple design.
     The first critique I received was to use three different LED colors instead of just one in order to show a variance in volume, the second came later on when it was pointed out that making this a full length mirror would allow people of different heights to use it and allow it to remain fixed however the current generation of this project is portable because everything is capable of fitting in the frame. In spite of this my project worked exactly as planned. I owe a large part of the assembly of this project to this site which provides both the code and schematic of how to connect everything to the Arduino. After following that guide i used Velcro tape to attach the breadboard to the fabric inside the shadow box, a strip of Velcro tape was included in the frame when I purchased it.
     Everything needed to assemble this project is listed below as well as a video of it in use:
B.O.M.
9 volt battery x1
Arduino Uno x1
5″x7″ Shadow box picture frame x1
Jumper wires x14
Electret Microphone Amplifier x1
330 ohm resistors x8
LEDs x8
Bread board x1
9 volt battery connector x1
Mirror Film x1

#define N_PIXELS  8  // Number of LEDs
#define MIC_PIN   A0  // Microphone is attached to this analog pin
#define DC_OFFSET  0  // DC offset in mic signal – if unusure, leave 0
#define NOISE     10  // Noise/hum/interference in mic signal
#define SAMPLES   60  // Length of buffer for dynamic level adjustment
#define TOP       (N_PIXELS + 2) // Allow dot to go slightly off scale
#define PEAK_FALL 40  // Rate of peak falling dot
const int led[] = {4,5,6,7,8,9,10,11};
byte
peak      = 0,      // Used for falling dot
dotCount  = 0,      // Frame counter for delaying dot-falling speed
volCount  = 0;      // Frame counter for storing past volume data
int
vol[SAMPLES],       // Collection of prior volume samples
lvl       = 10,      // Current “dampened” audio level
minLvlAvg = 0,      // For dynamic adjustment of graph low & high
maxLvlAvg = 512;

void setup() {
analogReference(EXTERNAL);
memset(vol, 0, sizeof(vol));
for(int i=0; i<N_PIXELS; i++)
{
pinMode(led[i],OUTPUT);
}
}

void loop()
{
uint8_t  i;
uint16_t minLvl, maxLvl;
int n, height;
n   = analogRead(MIC_PIN); // Raw reading from mic
n   = abs(n – 512 – DC_OFFSET); // Center on zero
n   = (n <= NOISE) ? 0 : (n – NOISE);     // Remove noise/hum
lvl = ((lvl * 7) + n) >> 3;    // “Dampened” reading (else looks twitchy)

// Calculate bar height based on dynamic min/max levels (fixed point):
height = TOP * (lvl – minLvlAvg) / (long)(maxLvlAvg – minLvlAvg);

if(height < 0L) height = 0; // Clip output
else if(height > TOP) height = TOP;
if(height > peak) peak = height; // Keep ‘peak’ dot at top

for(i=0; i<N_PIXELS; i++)
{
if(i < height)
{
digitalWrite(led[i], HIGH);
}
else
{
digitalWrite(led[i], LOW);
}
}
if(peak > 0 && peak <= N_PIXELS-1)
{
// colour peak dot
}
if(++dotCount >= PEAK_FALL) { //fall rate

if(peak > 0) peak–;
dotCount = 0;
}
vol[volCount] = n;   // Save sample for dynamic leveling
if(++volCount >= SAMPLES) volCount = 0; // Advance/rollover sample counter
// Get volume range of prior frames
minLvl = maxLvl = vol[0];
for(i=1; i<SAMPLES; i++) {
if(vol[i] < minLvl) minLvl = vol[i];
else if(vol[i] > maxLvl) maxLvl = vol[i];
}
if((maxLvl – minLvl) < TOP) maxLvl = minLvl + TOP;
minLvlAvg = (minLvlAvg * 63 + minLvl) >> 6; // Dampen min/max levels
maxLvlAvg = (maxLvlAvg * 63 + maxLvl) >> 6; // (fake rolling average)
}

Circuit Diagram

Final Project: The WAB and prospective BAB

Hey all,

So my final project is a prospective project in which I would like to create called the Bluetooth Audio Box (BAB). This consist of an arduino, preferably an uno, an mp3 shield, and a bluetooth shield.  You would also need a speaker/headphone, micro SD card, and a smart device (android / iOS) as hardware parts to make this project at least 90% complete. To make it presentable for the public, you would have to shelter it with plastic casing, a project enclosure, or a 3D printable object in which I  intend to use for representing my project. The object was designed as a mini speaker case in which the hardware system could be implemented and concealed properly, and safely.

Basically, it is a portable MP3 Player, that outputs mp3 music files via bluetooth from my smartphone (android) preferably to a speaker. Essentially, I really like the idea of installing this hardware system inside a 3D printable mini speaker case because it would be ideal, conceptual, appear captivating to its audience, and most of all seem really cool to me to have a mini “set”. I got inspired to build something that is so creative, interesting and amazing by the portable bluetooth speakers they sell in the electronic stores such as Best Buy, Radio Shack, and Walmart…etc. I realized that stepping outside of the box and applying yourself can get you as far you could want without limitations. So why not build one! “The seemingly impossible is possible” by Hans Rosling.

I was mainly inspired  by this project created by ‘Annikken’:

1) http://www.instructables.com/id/Andee-MP3-Player-Play-your-music-on-Arduino-via-Sm/?ALLSTEPS

Initially, my project setup was similar as the video presented below except the use of the motion sensor and its functionality towards that project in particular. Take a look at what it’s all about:

What I noticed from the link is the person didn’t provide any resources that could help someone build or improvise on that project. No code, materials, or instructables were provided.  I did notice on the other hand that he was using an Arduino with a speacial feature called a wave shield, which was actually part of my project originally. It is available at Adafruit.com, follow the link below:

https://learn.adafruit.com/adafruit-wave-shield-audio-shield-for-arduino

This is particular type of shield facilitates a music and sound pack as an additional feature. It allows music to be uploaded to the arduino via SD card and for sound sound quality it accepts only uncompressed music files (WAV) that gives audio its maximum potential.

Secondly, I thought of transitioning my project into something more ‘eye popping’ that would send off a deep feeling of awe and respect so to speak. Basically, instead of my object only changing songs all the time, I would like it to have LED’s flashing in a synchronized manner to the beat of the rhythm. Take a look at these two videos to conceive what it is I’m trying to portray.

This one below is more completed, but unfortunately it doesn’t use Arduino. Take a look:

I was also inspired by the previous video which can be found at instructables.com, I found it to be an enticing project that could enlighten one’s imagination, using lights and music to generate something magical is quite appalling. It was created by Motadacruz, who explained that the lights start to flash to the base of the speaker whenever music is being played.  Here’s the link below for more details:

http://www.instructables.com/id/Music-LED-Light-Box/?ALLSTEPS

I can see everybody using my project either for public, or for their personal use, especially during their down/relaxing time. It’s meant to be used mostly for small scale locations depending on the context, such as; get-together parties, internal privacy (bedrooms, home entertainment rooms, car internal music stereo) and so on….

Professor Don, and a few others tested my original project, the one with the wave shield, with no LED flashing lights implementation.  They both were able to listen the wave audio file via head phones, and Professor Don gave comments with regards to its’ pros and its’ cons. Unfortunately, I did not record any of my encounters. Perhaps I was a bit overwhelmed with the setting and everything that was taking place. I was quite content with the fact that the project actually played my wav audio file in terms doing what it is supposed to do, however it still required some work to be done in order for it to be 100% complete, thus meeting my complete expectations. The approach I would take as an adjustment to improve my project is firstly, obtain an mp3 shield instead of a wave shield. This would make my life so much easier because the mp3 shield is already coded in such a way, it connects with the Annikken Andee (Bluetooth shield) as demonstrated from the instructables link previously mentioned. As a result, this allows better and more successful interaction between the annikken andee software and the mp3 shield. It was quite a challenge to derefernce what was referenced in the mp3 shield libraries to that of the wave shield libraries, and due to circumstances I ran out of time.

The materials and components used to build this project was appropriate and necessary enough to make it a working system, and based on its built and design it’s quite modular due to it’s capability of doing so many things, such as interacting with it from your phone via bluetooth technology, implementing LED lights to glow in dark and flash to the rhythm, integrating a PIR sensor to play music whenever senses motion, and the list goes on…

Hopefully, I can put everything together to make it happen! I’m also happy that the Arduino board is multi-funtional as mentioned before, therefore audio is played asynchronously as an interrupt, and the arduino can perform tasks while the audio is playing. What this means is that, the arduino prioritizes, where as audio is priority because music is life!

I re-contextualize this project in such a way to call it my own. It is called the “BAB” because of what it represents, a Bluetooth Audio Box, which I believe deserves an actual name, perhaps something that could even be marketable. I find it quite unique because it is capable of doing so many things to make it interesting.

I really hope my readers can concieve the same vision I have for this project. At first I encountered an obstacle (explained further along), so I had to slightly change the course of its’ development, and transitional process for clarity and direction, thus developing a story behind it. Therefore with respect to the original project in which I stood beside whether by choice, or by default, I still appreciate what I accomplished with it. To reiterate the project consisted of; an arduino uno, wave shield, and annikken andee (bluetooth shield), and a speaker. he code was straight forward,  and comprehensible on that end. The design is quite impressive and built seems really layered, and compact. Its really wonderful how people should react to this project. For one, it prompts them to dance and feel good within themselves, if you’re a spiritual type of person it gives off an energy of life to the soul, and pretty much any vibe that music provides to an individual.

The arduino programming language was the only programming language I used for this project. The code or sketch used is the “dapHC.pde” meaning  Digital Audio Player (dap) found in the Wave shield library folder, which references to the Wave HC libraries. What it basically does is play wav files in a continuous loop. Therefore I call this version of my project, the “Mixtape Audio Box (MAB), because the music plays in a loop as if you would play mixtape or a duplate at a ‘set’ (dj setting). As mentioned before, the code was very straight forward, I believe sufficient comments were provided for clarity, and direction. The only point I was able to troubleshoot or debug for errors was at the stage of compiling the wave shield sketch to connect with the annikken andee sketch. I brought it down from about 30 errors to 3 errors with some help of one my colleague, and friend. Adafruit was quite unresponsive to my blog post based on the issue, therefore I accepted the fact that I should I have gotten the mp3 shield in the first place. I was trying to be conservative with the funding of the project, but on the contrary I ended up over spending. The code or sketch provided to make this music system operate can be found below:

/*
* This example plays every .WAV file it finds on the SD card in a loop
*/
#include <WaveHC.h>
#include <WaveUtil.h>

SdReader card; // This object holds the information for the card
FatVolume vol; // This holds the information for the partition on the card
FatReader root; // This holds the information for the volumes root directory
WaveHC wave; // This is the only wave (audio) object, since we will only play one at a time

uint8_t dirLevel; // indent level for file/dir names (for prettyprinting)
dir_t dirBuf; // buffer for directory reads
/*
* Define macro to put error messages in flash memory
*/
#define error(msg) error_P(PSTR(msg))

// Function definitions (we define them here, but the code is below)
void play(FatReader &dir);

//////////////////////////////////// SETUP
void setup() {
Serial.begin(9600); // set up Serial library at 9600 bps for debugging

putstring_nl(“\nWave test!”); // say we woke up!

putstring(“Free RAM: “); // This can help with debugging, running out of RAM is bad
Serial.println(FreeRam());

// if (!card.init(true)) { //play with 4 MHz spi if 8MHz isn’t working for you
if (!card.init()) { //play with 8 MHz spi (default faster!)
error(“Card init. failed!”); // Something went wrong, lets print out why
}

// enable optimize read – some cards may timeout. Disable if you’re having problems
card.partialBlockRead(true);

// Now we will look for a FAT partition!
uint8_t part;
for (part = 0; part < 5; part++) { // we have up to 5 slots to look in
if (vol.init(card, part))
break; // we found one, lets bail
}
if (part == 5) { // if we ended up not finding one :(
error(“No valid FAT partition!”); // Something went wrong, lets print out why
}

// Lets tell the user about what we found
putstring(“Using partition “);
Serial.print(part, DEC);
putstring(“, type is FAT”);
Serial.println(vol.fatType(), DEC); // FAT16 or FAT32?

// Try to open the root directory
if (!root.openRoot(vol)) {
error(“Can’t open root dir!”); // Something went wrong,
}

// Whew! We got past the tough parts.
putstring_nl(“Files found (* = fragmented):”);

// Print out all of the files in all the directories.
root.ls(LS_R | LS_FLAG_FRAGMENTED);
}

//////////////////////////////////// LOOP
void loop() {
root.rewind();
play(root);
}

/////////////////////////////////// HELPERS
/*
* print error message and halt
*/
void error_P(const char *str) {
PgmPrint(“Error: “);
SerialPrint_P(str);
sdErrorCheck();
while(1);
}
/*
* print error message and halt if SD I/O error, great for debugging!
*/
void sdErrorCheck(void) {
if (!card.errorCode()) return;
PgmPrint(“\r\nSD I/O error: “);
Serial.print(card.errorCode(), HEX);
PgmPrint(“, “);
Serial.println(card.errorData(), HEX);
while(1);
}
/*
* play recursively – possible stack overflow if subdirectories too nested
*/
void play(FatReader &dir) {
FatReader file;
while (dir.readDir(dirBuf) > 0) { // Read every file in the directory one at a time

// Skip it if not a subdirectory and not a .WAV file
if (!DIR_IS_SUBDIR(dirBuf)
&& strncmp_P((char *)&dirBuf.name[8], PSTR(“WAV”), 3)) {
continue;
}

Serial.println(); // clear out a new line

for (uint8_t i = 0; i < dirLevel; i++) {
Serial.write(‘ ‘); // this is for prettyprinting, put spaces in front
}
if (!file.open(vol, dirBuf)) { // open the file in the directory
error(“file.open failed”); // something went wrong
}

if (file.isDir()) { // check if we opened a new directory
putstring(“Subdir: “);
printEntryName(dirBuf);
Serial.println();
dirLevel += 2; // add more spaces
// play files in subdirectory
play(file); // recursive!
dirLevel -= 2;
}
else {
// Aha! we found a file that isnt a directory
putstring(“Playing “);
printEntryName(dirBuf); // print it out
if (!wave.create(file)) { // Figure out, is it a WAV proper?
putstring(” Not a valid WAV”); // ok skip it
} else {
Serial.println(); // Hooray it IS a WAV proper!
wave.play(); // make some noise!

uint8_t n = 0;
while (wave.isplaying) {// playing occurs in interrupts, so we print dots in realtime
putstring(“.”);
if (!(++n % 32))Serial.println();
delay(100);
}
sdErrorCheck(); // everything OK?
// if (wave.errors)Serial.println(wave.errors); // wave decoding errors
}
}
}
}

The input is convert all mp3 files to wav files using mp3 to wave file converter and ensure its format is at 16- bit, and at a frequency of 22KHz or less. The expected build time I’d say was 336 hrs for the original version (WAB) and cost  me about $120.00. In total I spent about $180.00 on an average of 600 hrs trying to complete both versions, but only succeeded with one in the given time frame. Needless to say that’s just the first phase of the project or the first version rather. Therefore had I acted more assertively to transition and leave that aside for later, perhaps I would have been able to display the ideal version at the presentation.

Furthermore, one of the major issue I foresee as a challenge is having to think about the whole contextualizing process encapsulated inside the 3D object, I wasn’t a 100% sure if it was doable putting two ideas together to make, given the time frame I had, but I hoped for the best, where as the surface area of my object would be large enough to satisfy the whole idea of my project.

Another challenge I see is when I’m putting everything together and setting up the circuit for the components to work properly and efficiently. Also, implementing the code that does the three task: motion reactive LEDs  -> music playing && LED modulation at the same time (lights jumping to the beat of the sound).

Then an instuctables to setup blinking LED’s that responds to the beat of the music:

1) http://www.instructables.com/id/How-to-Make-LEDs-Flash-to-Music-with-an-Arduino/?ALLSTEPS.

This piece of art deserve to exist because it can be used everyday, I find it to be an inspiration based on the story of Davilon which brings the message of peace, love and unity. Hence, the reason I gave it life through music as part of the connection to its identity (why does it do what it does). As mentioned before ‘Music is Life’. Also, there are some sentimental attachment to this art piece and that’s why I intend to make it a worthy project.

Here’s a video showing its dimensions and how one interacts with it.

https://www.youtube.com/watch?v=G-gq1beB9go

Bill of Materials

1 x Annikken Andee (Android or iOS) ———> Arduino.con (€59.90)

1x MP3 Shield ($39.95)

1 x Arduino Uno ($ 10.00)

1 x MicroSD card(comes with wave shield)

1 x Smart Device (Android/ iOS)

Music and sound add-on pack wave shield for Arduino—->  Adafruit.com ($35.00)

Stereo enclosed speaker set – 3W 4 Ohm —-> Adafruit.com (comes with wave shield)

Alkaline 9V battery —–> Adafruit.com ($2.50)

9V battery clip with 5.5 mm/2.1mm plug ——> Adafruit.com

TOOLS

  • adafruit_products_soldering_iron.jpeg
  • adafruit_products_soldering_iron.jpeg
  • adafruit_products_soldering_iron_upgrade.jpeg
Soldering ironAny entry level ‘all-in-one’ soldering iron that you might find at your local hardware store should work. As with most things in life, you get what you pay for.Upgrading to a higher end soldering iron setup, like theHakko FX-888 that we stock in our store, will make soldering fun and easy.

Do not use a “ColdHeat” soldering iron
! They are not suitable for delicate electronics work and can damage the kit (see here).Click here to buy our entry level adjustable 30W 110V soldering iron.

Click here to upgrade to a Genuine Hakko FX-888 adjustable temperature soldering iron.

  • adafruit_products_solder.jpeg
SolderYou will want rosin core, 60/40 solder. Good solder is a good thing. Bad solder leads to bridging and cold solder joints which can be tough to find.Click here to buy a spool of leaded solder (recommended for beginners).Click here to buy a spool of lead-free solder.

  • adafruit_products_ID71multimeter_LRG.jpeg
  • adafruit_products_ID71multimeter_LRG.jpeg
  • adafruit_products_extech330_LRG.jpeg
  • adafruit_products_ID850_LRG.jpeg
Multimeter

You will need a good quality basic multimeter that can measure voltage and continuity.Click here to buy a basic multimeter.Click here to buy a top of the line multimeter.Click here to buy a pocket multimeter.

  • adafruit_products_cutter.jpeg
Flush Diagonal CuttersYou will need flush diagonal cutters to trim the wires and leads off of components once you have soldered them in place.Click here to buy our favorite cutters.

  • adafruit_products_soldersucker_LRG.jpeg
Solder SuckerStrangely enough, that’s the technical term for this desoldering vacuum tool. Useful in cleaning up mistakes, every electrical engineer has one of these on their desk.Click here to buy a one.

  • adafruit_products_thirdhand_LRG.jpeg
Helping Third Hand With MagnifierNot absolutely necessary but will make things go much much faster, and it will make soldering much easier.Pick one up here.

Components for wave shield

 

The Photo Finally Has Arrived!

IMG_2384 IMG_2383

 CUSTOMER NAME VTORIA MARQUEZ
CUSTOMER ADDRESS 135 34TH ST FIXITVILLE, NY, 11101
DATE 2/9/2015
Item DESCRIPTION VENDOR PART NUMBER QUANTITY
1 OEM ZTE LCD( LIQUID CRYSTAL DISPLAY) ZTE N/A 1
2 OEM ZTE CONCORD FRONT HOUSING ZTE N/A 1
3 OEM ZTE CONCORD TOUCH SCREEN DIGITIZER ZTE N/A 1
4 CONCORD REAR BACK HOUSING WITH CAMERA LENS ZTE N/A 1
5 OEM ZTE CONCORD MIDDLE PLATE ZTE N/A 1
6 CONCORD BACK COVER(BATTERY DOOR) ZTE N/A 1
7 GSM MOTHER BOARD UNKOWN N/A 1
8 OEM ZTE CONCORD V768 NAVIGATOR PCB BOARD ZTE N/A 1
9 OME ZTE CONCORD V786 REAR FACING CAMERA ZTE N/A 1
10 OEM ZTE CONCORD V768 SIGNAL WIRE ZTE N/A 1
11 OEM ZTE CONORD V768 EAR SPEAKER ZTE N/A 1
12 OEM ZTE CONCORD V768 LOUD SPEAKER ZTE N/A 1
13 SIM CARD T-MOBILE N/A 1
14 OEM ZTE BATTERY ZTE 10101305205426400 1
15 SCREWS UNKOWN N/A 7

For our become a part of something assignment I took a part two different items. Which were my CONCORD ZTE V768 smart phone and my old Targus computer mouse. The first object I took a part was the old smart phone, which was to my surprise, a lot harder to disassemble without destroying it than I originally thought. The reason for this was that, like we all know, cell phones are not meant to come a part or break easily, so when they’re made a lot of glue and other things are used to keep it together. So when I eventually opened up the phone there was a glue like substance on the majority of the parts, the covers, etc. and there were also several screws that were keeping the middle plate attached, which helps protect the more sensitive materials of the phone.AdobePhotoshopExpress_2015_02_09_19_57_27AdobePhotoshopExpress_2015_02_09_19_47_12
My biggest problem with these screws was not just unscrewing them, but the fact that I couldn’t see all of them. There was a hidden screw, that was covered with some kind of dark pigmented glue, which I had to scrape off to see and then carefully un screw. Which was an issue because the area was kind of worn after I scraped off the glue and I couldn’t take the middle part of the phone out, to get to the mother board and more, without taking this one screw out. Unluckily enough I encountered a few more issues with the removal of the touch screen digitizer (screen that was already broken) and the GSM mother board. I didn’t want to cause further damage or sacrifice the GSM so I ended up taking a Philips head screw driver(with the help of Professor Phelps) and pushing it up/under the screen so that I could get to a strip that was underneath and I clipped it so that I could separate it and put it in my final Picture.AdobePhotoshopExpress_2015_02_09_22_31_47AdobePhotoshopExpress_2015_02_09_19_56_01FullSizeRender
After I pried it open and was able to separate it all there were a bunch of little pieces and parts that I was also able to separate from the phone as well. These items were the Navigator PCB board, the rear facing camera, the signal wire, the ear and loud speakers that are very small.

FullSizeRender (1)

AdobePhotoshopExpress_2015_02_09_19_50_17

CUSTOMER NAME VICTORIA MARQUEZ
CUSTOMER ADDRESS 135 34TH ST FIXITVILLE, NY, 11101
DATE 2/9/2015
Item DESCRIPTION VENDOR PART NUMBER QUANTITY
1 BOTTOM OF THE MOUSE (PORTION THAT TOUCHES THE TABLE) UNKNOWN N/A 1
2 LEFT AND RIGHT CLICK (TOP PORTION) UNKNOWN N/A 1
3 BODY OF THE MOUSE(COVERS CENTER PORTION) UNKNOWN N/A 1
4 USB CABLE UNKNOWN N/A 1
5 UNKOWN PLASTIC PIECE UNKNOWN N/A 1
6 UNKOWN PLASTIC PIECE UNKNOWN N/A 1
7 SCREWS UNKNOWN N/A 3
 8 SCROLL WHEEL UNKNOWN N/A 1

The second item I took disassembled was an old TARGUS model mouse which compared to taking a part the phone was extremely easy and a lot less complicated to take a part and photograph mainly because there are so few pieces and the mouse its self is not very sturdy. So the only thing that I had to really do was unscrew three little screws that kept the bottom pieces together, so that I could get the scroll wheel from between two different pieces of plastic that kept it in place. One of the screws also had a strange little ring around it that I was able to save and did not lose!

FullSizeRender (3)FullSizeRender (2)

 

3D Printing Conference Attendance: The Fair!

IMG_3055 IMG_3060


 

Getting to the convention was a bit difficult but definitely worth the trip because it’s an amazing opportunity to find out more about 3D printing and other things that go hand and hand with them.

While at the Convention I heard a lot of conversations about how each item works, the pricing for each one (which were wild), the programs included or needed for certain items, the maintenance of these items and also there was a lot of talk about testing some of the devices there.

IMG_3048 There were three 3D printers that I saw while there that I found particularly interesting. First there was the Lulzbot 3D Printer (from the Aleph Objects Inc. In the picture above), the MakerOS  3D Printer (that runs on the cloud or OS save important data etc.) and the Mcor Technologies Ltd Printer (that uses regular printing paper to make 3D items). They were all 3D Printers but they were all built differently, some were larger than the others, they run differently, the had different programs/software and their prices varied a great deal.

IMG_3046

It’s hard to pick the most interesting thing I saw at the fair but I think it would be the 3D printed car that was, possibly, built completely of 3D printed parts and then was placed towards the left side of the room where it took up several feet of space. I know that there were a lot of other really cool things at the convention but the I thought this was the most interestingIMG_3034 because whoever made this took tons of time to plan out, print and then piece together every single 3D printed part used to build this car, they must have pretty intimate knowledge of the way a car is built and an exaggerated amount of patience to build this. I really Enjoyed the artwork and fun items that were displayed because some of the pieces were for sale and some weren’t but you were still allowed to interact or touch them and even try some on!


IMG_3033IMG_3045IMG_3031IMG_3051IMG_3037

IMG_3040

 

 

 

 

 

Novo Aduro Final Project And Reflection

Everything started when I visited my friend’s house. He had home automation everywhere and had lights that he could control through his phone. I was just left in awe. I did not know it was possible to have lights change colors to whatever I wanted. This is why I decided to name my project “Novo Aduro”. It stems from the latin roots that originate from new and light, respectively. I think this name was perfect because my project’s idea really revolved around lights. The “Aduro” part fits in perfectly as well because I wanted to find a way to re-contextualize projects that use RBG or neopixel lights.  After this is when I finally figured out in what direction I wanted to go with my project! I went through a lot of projects that I wanted to reverse-engineer, but the one that really caught my attention was the ambient lighting. Below you can find some of my inspirations:

  • Firefly LED Jar – a static version of what I am trying to do. The idea is the same, but the overall concept is fairly different, thus making it very hard to use. I still like how the final product resemble a lamp that can illuminate based on different colors.
  • Mood Lighting – A little lamp that changes colors based on someone’s mood. I like the idea, but the shape for the lamp was not attractive, nor was any code that can be easily modified provided.
  • Bluetooth controlled LED –  This is fairly close to what I want! Instead of using bluetooth, I want to connect it with wires first. And instead of using an application, I want to use a touchpad that directly mounts to an Arduino.
  • Ambient Computer lights – Uses neopixels instead of standard RGB LED’s, which is basically what I want to do.
  • Led Cube – Pretty much a mix of all of the other projects that inspired me. This inspired me the most!

As I mentioned in my previous post, I feel like the connection between the neopixels and my touchpad shield will be the biggest problem. Just by looking at the schematics, I can see that the shield will cover the whole entire Arduino Uno. How will I hook up my neopixels if the screen will take up all of the space?  Aside from this problem, there also exists a similar troublesome problem as well. This problem, even though it targets a different part of the project, is still something I see myself having trouble with in the future. This is the fact that my project is not really concrete. My re-contextualization is basically changing up my references completely and modifying the majority of it. Since I am heavily modifying everything, the BOM will not be accurate, I will have to get different code bases, and I will have to try to look at other projects for help and tips during this construction process. Using these links as my inspiration, I was able to finish my bill of materials as well.

BOM:

Novo Aduro is going to be one of a kind. Something so complicated internally yet externally simple to use. Something so efficient and useful yet often overlooked. It’s going to be a handmade lamp with some neopixels inside that can change color according to the absolute position on the touchpad. Using this touchpad you can change the color and even the brightness. You can mix and match colors and literally create endless possibilities! This does not stop here. After this is done, I also have many improvements I would like to make to it. Instead of being a standalone portable LED customizable lamp, I would like to make it daisy chain-able. I would like to be able to make several lamps and control them all together using just one touchpad. I can take it even further by later creating an app that can control all of them over wifi or bluetooth to truly serve the purpose of true home automation. For now though, I would like to make this lamp very efficient with a nice and elegant UI and UX interface, that rapidly as well as swiftly responds to the touchpad and instantly produces the desired color effect with minimal lag/latency. I want my finished product to be very user-friendly so that I can target every audience without an age restriction as well. Just think about it. Instead of going out and wasting so much money on something that looks plain and can not be customized to your liking, is not very fun. If you have kids, it will not catch their interest. With this Novo Aduro, you can change colors to match lullabies to put kids to sleep as well as match the color for the room on a romantic evening. The possibilities of this creation is endless, and that is why I think it deserves to exist and serve it’s purpose by being accessible to the community.

Now that I have all of my ideas planned out, I realized how much I just love how everything can affect the lights to change into different colors. My version a.k.a re-contextualization of the projects I used for inspiration, really bears fruit with the simplicity of lights and the ease of the user interface. So it got me thinking. If I can find a way to make something with lights that users can have fun with, it will be perfect. Even more so because my target audience has no boundaries. I wanted anyone ranging from a child all the way to an adult to be able to use and operate my project with no learning curve whatsoever. This gave me the idea of 3D printing a lamp that turned on according to someone’s mood. Since I love Japanese culture, I decided to go with a modern japanese-style lamp, which can be found here. I customized it a little bit to my liking and added some new things to it to make it hold plexiglass all around the sides.

This is the piece that will hold me plexiglass. I added four of them to my lamp on each side, and printed it all assembled together.

20150512_085310

This is a video of it printing:

After the piece finished printing, I had to take off all of the support that printed with it. After it’s completion, I left it at home for a few hours and went to school to finish soldering some wires. By the time I came home, this is what I found:

IMG_20150513_180640:nopm:It was completely broken! I had to run to an arts and crafts store to buy a little wooden box to replace it with. I then made some cut-outs for the power cables and spray-painted it black.

Time to move on to the actual core of the project: The touchscreen. The touchscreen shield is really what makes this project since it’s what bridges my project with the neopixels. I used a breadboard to make all of my connections. I broke out the pins of the touchshield along with digital pin 6 for the neopixels and power and ground. The pins for the touch shield were unnecessary, but since I didn’t really know if i would be needing it, I broke it out just in case. I then bought a neopixel stick to practice with before using the neopixel strip for the final version. Below are some pictures of my setup:

20150505_173627

20150505_173656

20150505_173742

20150505_173548

IMG_20150506_142836:nopm:

20150508_165305

The problem with my current idea of the lamp is that the user interface was pretty boring. Just touching the lamp is way too simple. I then had to think a little deeper. After searching for new innovative ideas, it finally hit me! Why don’t I stick with my original lamp idea and just have a touchscreen that connects to it where the user can change the color whenever they want. During class, however, especially after receiving a lot of feedback, I realized I had to research twice as much as everyone else because my project is really all custom code. There is no code to match my idea of having a custom user interface on a touchscreen shield where it is directly linked to some kind of lights. The positive side of this is that I can put it anywhere in my home. It is not restricted to a specific device like ambient lighting where it has to be on an object like a tv or monitor. The ending result is something that can be more accessible by others! Since I am re-contextualizing this project to the extreme, a lot of the stuff I want to do will not be included in the project that I got this idea from.

It was finally time to switch to my neopixel strip! The problem with the strip was that the connector wires were soldered to the wrong end. I had to cut off the water-proof film and de-solder it. Solder back the wires and then soldered it to the other side of the strip where the data input side was located.

20150508_201401

20150508_204629

After finishing all of the soldering and connections, it was finally time to test the strip! Since I practiced with the neopixel stick already, it was fairly easy to switch the strip. Below you can find some pictures and videos of the strip testing!

20150508_234604

It was finally time to work on the touchshield! The only issue I had was with the number of pins available after connecting the touch shield. I had to breakout the pins in order to solder them together, which was a real hassle for me because I am not a hardware person. The code I used was customized for my specific purpose. All it simply does is button map a whole bunch of coordinates creating a grid where a user gets to touch down on any box displaying on the screen, and whatever color inside that box will be sent to the neo-pixels in order to update it. Button mapping it was actually very hard though. I added comments in a few places to depicting exactly what I was doing which really helped me out with all of the debugging I had to do before it being open to the public. The code can be found at the end of this post.

20150512_195208

20150512_195202

It came out really nice and colorful just how I wanted it to be. The six numbers on the bottom are all different effects that the neopixels can make. The static colors are on top and the bottom is more for dynamic changing lights giving the user the option to switch between them fairly easily! Now, it’s time for testing!

20150512_194334

It was finally time to finish up this project by removing everything from the breadboard and soldering it together to fit in the box I bought. If I had enough time, I would’ve loved to create the little lamp box myself, but since I was also preparing for NASA’s 2015 Robotic Mining Competition, I didn’t really have the time. Below you can see some pictures of how I was putting everything together to mold around the shape of the lamp shade.

20150516_155253

20150516_161401

20150515_235404

After completing this project, I had an art show I had to attend, which counted as part of the final grade.

20150514_132801

In this art show I had to show off my creation to everyone. People were asking me questions about how I got my touchscreen working with the lights and how I was able to make the custom code. Since I am majoring in Computer Science, I was able to understand the Arduino language, which I had to use to work with my Arduino Uno. After understanding the code, I was able to create my own using it as a reference. The reactions everyone had were priceless. I had no idea people were going to be that surprised by my project. They were just surprised as me when I first thought of the idea of having changing lights. These people have never seen technology like this, so It was pretty interesting to see how in shock they were. Since my touchscreen shield was re-located to the top of the lamp I have, it was viewable by anyone. I then covered the lamp with a black cloth to change the way the lights look. Since the room was pretty dark, my camera didn’t focus really well, but you can see that the touchshield is on top of the lamp.

20150514_130152

As soon as people saw the colors of the shield, they just instinctively wanted to touch it. It was pretty crazy, but fun at the same time. I was also talking to people about our york college robot that we were heavily testing at the time for Nasa’s robotic mining competition.

20150514_132604

I had no feedback at all from anyone. No one gave me suggestions or anything on how to make it better. I am not surprised because many of them were just there for sightseeing, but from the reactions I got, I think it was perfectly fine the way it is. My project worked exactly as intended, which was very nice. This obviously meant that all of the components used made sense and were self-explanatory. Since this project only used the arduino language, it was pretty easy to put it all together since I just had to focus on one language. I put efficient comments everywhere so the people reading the code, know exactly what is happening, and it also makes it easier to debug. I did a lot of debugging. In fact, most of my time was spent debugging. Mainly because I didn’t have any tutorials to look at when building it. Because of this my build time was pretty long. It took me about three weeks to finish everything, including all of the research I had to do. My lamp’s dimensions were fairly small. It was a 4.5 x 4.5 x 4.5 inch cube. Mounting the arduino on top, bumped up the height to 6 inches though.

Since my project is very flexible and portable, it can actually be used by anyone! This is what makes it so nice. The fact that anyone can use it, modify it, contribute or even build off of mine is amazing. It simply used the input of the user via the touchscreen interface to light up the neopixels as the output. This makes it relatively simple for anyone to use especially since I am contributing to the community. Just knowing that people are actually using my stuff, is just unbelievably awesome as well! I can see people using this for many things. If they want to build it just how I am creating it, then they can use it as a lamp just how anyone normally would. Now if they want to modify it, they can also. They can turn it into ambient lighting, shelf lighting, lighting controlled by voice or anything else involving the use of LED’s. Creative people will love my project the most. The fact that you have so much power over the color and brightness of each and every individual pixel, while still keeping the user interface nice and simply, will give off a user friendly approach attracting a lot of people especially those who love home automation.

I think I did really well for my first time using an arduino. I learned the language fairly quickly, and using my knowledge in computer science, I was able to work my way around many obstacles. My final project came out very nice. So nice, in fact, that even I was surprised that it was my first time messing around with this stuff. Given the facts that I am new to this, and that the project came out to be such a great success, If I were to give myself a grade, it would definitely be an A! I feel very confident and proud, that given my lack of resources and time, I was able to pull off such a great feat as this. This project was just so much fun, and I would love to do build something new sometime in the future!

This is the final product without using the breadboard. The breadboard was just connected to the little mount I had to hold the arduino in place, but it is not being used nor does it affect the project in any way. Enjoy!

20150516_162958


Arduino Source Code

#include <Adafruit_GFX.h> // Core graphics library
#include <SPI.h>
#include <Wire.h> // this is needed even tho we aren’t using it
#include <Adafruit_ILI9341.h>
#include <Adafruit_STMPE610.h>

#include <Adafruit_NeoPixel.h>
#include <avr/power.h>

#define PIN 6
#define NUMPIXELS 60

// This is calibration data for the raw touch data to the screen coordinates
#define TS_MINX 150
#define TS_MINY 130
#define TS_MAXX 3800
#define TS_MAXY 4000

// The STMPE610 uses hardware SPI on the shield, and #8
#define STMPE_CS 8
Adafruit_STMPE610 ts = Adafruit_STMPE610(STMPE_CS);

// The display also uses hardware SPI, plus #9 & #10
#define TFT_CS 10
#define TFT_DC 9
Adafruit_ILI9341 tft = Adafruit_ILI9341(TFT_CS, TFT_DC);

// Size of the color selection boxes, the paintbrush size and the amount of ROWS that fit on the screen
#define BOXSIZE 40
#define PENRADIUS 3
#define COLUMNS 6 //shades
#define ROWS 7 //colors
int oldcolor, currentcolor;

// Fixed-size offset for every box
#define MULTIPLIER_2 2
#define MULTIPLIER_3 3
#define MULTIPLIER_4 4
#define MULTIPLIER_5 5
#define MULTIPLIER_6 6
#define MULTIPLIER_7 7

#define DELAYVAL 50 // delay for 50ms
/** RED SHADES (Dark-to-light)
* Maroon – 128,0,0 => 0x8000
* Firebrick – 178,34,34 => 0xB104
* Crimon – 220,20,60 => 0xD8A7
* Red – 255,0,0 => 0xF800
* Indian Red – 205,92,92 => 0xCAEB
* light Coral – 240,128,128 => 0xF410
*/
uint16_t shadesOfRed[7] = {
0x8000,
0xB104,
0xD8A7,
0xF800,
0xCAEB,
0xF410
};

/** BLUE SHADES
* Navy – 0,0,128 => 0x0010
* Blue – 0,0,255 => 0x001F
* Deep Sky Blue – 0,191,255 => 0x05FF
* Light Sky Blue – 145,206,250 => 0x967F
* Cyan – 0,255,255 => 0x07FF
* Turquiose – 64,224,208 => 0x471A
*/

uint16_t shadesOfBlue[7] = {
0x0010,
0x001F,
0x05FF,
0x967F,
0x07FF,
0x471A
};

/** GREEN SHADES
* Olive – 128,128,0 => 0x8400
* Yellow Green – 154,205,50 => 0x9E66
* Lawn Green – 124,252,0 => 0x7FE0
* Green – 0,128,0 => 0x0400
* Lime Green – 50,205,50 => 0x3666
* Lime – 0,255,0 => 0x07E0
*/

uint16_t shadesOfGreen[7] = {
0x8400,
0x9E66,
0x7FE0,
0x0400,
0x3666,
0x07E0

};

/** ORANGE AND YELLOW SHADES
* Orange Red – 250,80,0 => 0xFA80
* Dark Orange – 255,140,0 => 0xFC60
* Orange – 255,165,0 => 0xFD20
* Golden Rod – 218,165,32 => 0xDD24
* Gold – 255,215,0 => 0xFEA0
* Yellow – 255,255,0 => 0xFFE0
*/

uint16_t shadesOfOrangeAndYellow[7] = {
0xFA80,
0xFC60,
0xFD20,
0xDD24,
0xFEA0,
0xFFE0

};

/** PURPLE AND PINK SHADES
* Blue Violet – 138,43,226 => 0x895C
* Purple – 128,0,128 => 0x8010
* Dark Magenta – 139,0,139 => 0x8811
* Medium Orchid – 186,85,211 => 0xBABA
* Deep Pink – 255,20,147 => 0xF8B2
* Magenta – 255,0,255 => 0xF81F
*/

uint16_t shadesOfPurpleAndPink[7] = {
0x895C,
0x8010,
0x8811,
0xBABA,
0xF8B2,
0xF81F

};

/** BROWN SHADES
* Saddle Brown – 139,69,19 => 0x8A22
* Sienna – 160,82,45 => 0xA285
* Chocolate – 210,105,30 => 0xD343
* Sandy Brown – 244,164,96 => 0xF52C
* Tan – 210,180,140 => 0xD5B1
* Wheat – 245,222,179 => 0xF6F6
*/

uint16_t shadesOfBrown[7] = {
0x8A22,
0xA285,
0xD343,
0xF52C,
0xD5B1,
0xF6F6

};

/** BLACK AND WHITE SHADES
* Black – 0,0,0 => 0x0000
* Dim Grey – 96,96,96 => 0x630C
* Gray – 128,128,128 => 0x8410
* Silver – 192,192,192 => 0xC618
* Light Gray – 211,211,211 => 0xD69A
* White – 255,255,255 => 0xFFFF
*/

uint16_t shadesOfBlackAndWhite[7] = {
0x0000,
0x630C,
0x8410,
0xC618,
0xD69A,
0xFFFF

};

uint16_t allShades[COLUMNS][ROWS] = {
// // Red
// { 0x8000, 0xB104, 0xD8A7, 0xF800, 0xCAEB, 0xF410 },
// // Green
// { 0x8400, 0x9E66, 0x7FE0, 0x0400, 0x3666, 0x07E0 },
// // Blue
// { 0x0010, 0x001F, 0x05FF, 0x967F, 0x07FF, 0x471A },
// // Orange and Yellow
// { 0xFA80, 0xFC60, 0xFD20, 0xFD20, 0xFEA0, 0xFFE0 },
// // Purple and pink
// { 0x895C, 0x8010, 0x8811, 0xBABA, 0xF8B2, 0xF81F },
// // Brown
// { 0x8A22, 0xA285, 0xD343, 0xF52C, 0xD5B1, 0xF6F6 },
// // Black and White
// { 0x0000, 0x630C, 0x8410, 0xC618, 0xD69A, 0xFFFF }

//Red Green Blue Orange Purple Brown Black
{0x8000, 0x8400, 0x0010, 0xFA80, 0x895C , 0x8A22 , 0x0000},
{0xB104, 0x9E66, 0x001F, 0xFC60, 0x8010 , 0xA285 , 0x630C},
{0xD8A7, 0x7FE0, 0x05FF, 0xFD20, 0x8811 , 0xD343 , 0x8410},
{0xF800, 0x0400, 0x967F, 0xFD20, 0xBABA , 0xF52C , 0xC618},
{0xCAEB, 0x3666, 0x07FF, 0xFEA0, 0xF8B2 , 0xD5B1 , 0xD69A},
{0xF410, 0x07E0, 0x471A, 0xFFE0, 0xF81F , 0xF6F6 , 0xFFFF}
};

//Declare the pixel object, so we can change the color later on in the code
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);

//5312 – ext

// Fill the dots one after the other with a color
void colorWipe(uint32_t c, uint8_t wait) {
for(uint16_t i=0; i<pixels.numPixels(); i++) {
pixels.setPixelColor(i, c);
pixels.show();
delay(wait);
}
}

void rainbow(uint8_t wait) {
uint16_t i, j;

for(j=0; j<256; j++) {
for(i=0; i<pixels.numPixels(); i++) {
pixels.setPixelColor(i, Wheel((i+j) & 255));
}
pixels.show();
delay(wait);
}
}

// Slightly different, this makes the rainbow equally distributed throughout
void rainbowCycle(uint8_t wait) {
uint16_t i, j;

for(j=0; j<256*5; j++) { // 5 cycles of all colors on wheel
for(i=0; i< pixels.numPixels(); i++) {
pixels.setPixelColor(i, Wheel(((i * 256 / pixels.numPixels()) + j) & 255));
}
pixels.show();
delay(wait);
}
}

//Theatre-style crawling lights.
void theaterChase(uint32_t c, uint8_t wait) {
for (int j=0; j<10; j++) { //do 10 cycles of chasing
for (int q=0; q < 3; q++) {
for (int i=0; i < pixels.numPixels(); i=i+3) {
pixels.setPixelColor(i+q, c); //turn every third pixel on
}
pixels.show();

delay(wait);

for (int i=0; i < pixels.numPixels(); i=i+3) {
pixels.setPixelColor(i+q, 0); //turn every third pixel off
}
}
}
}

//Theatre-style crawling lights with rainbow effect
void theaterChaseRainbow(uint8_t wait) {
for (int j=0; j < 256; j++) { // cycle all 256 colors in the wheel
for (int q=0; q < 3; q++) {
for (int i=0; i < pixels.numPixels(); i=i+3) {
pixels.setPixelColor(i+q, Wheel( (i+j) % 255)); //turn every third pixel on
}
pixels.show();

delay(wait);

for (int i=0; i < pixels.numPixels(); i=i+3) {
pixels.setPixelColor(i+q, 0); //turn every third pixel off
}
}
}
}

// Input a value 0 to 255 to get a color value.
// The colours are a transition r – g – b – back to r.
uint32_t Wheel(byte WheelPos) {
WheelPos = 255 – WheelPos;
if(WheelPos < 85) {
return pixels.Color(255 – WheelPos * 3, 0, WheelPos * 3);
} else if(WheelPos < 170) {
WheelPos -= 85;
return pixels.Color(0, WheelPos * 3, 255 – WheelPos * 3);
} else {
WheelPos -= 170;
return pixels.Color(WheelPos * 3, 255 – WheelPos * 3, 0);
}
}

//Maps the 5:6:4 RGB HEX values to it’s distinct r, g, and b values and updates the color of the neopixels
void showPixelsWithColor(uint16_t color) {
int r,g,b;
switch (color) {
// Shades of Red
case 0x8000:
r = 128; g = 0; b = 0;
break;
case 0xB104:
r = 178; g = 34; b = 34;
break;
case 0xD8A7:
r = 220; g = 20; b = 60;
break;
case 0xF800:
r = 255; g = 0; b = 0;
break;
case 0xCAEB:
r = 205; g = 92; b = 92;
break;
case 0xF410:
r = 240; g = 128; b = 128;
break;

// Shades of Blue
case 0x0010:
r = 0; g = 0; b = 128;
break;
case 0x001F:
r = 0; g = 0; b = 255;
break;
case 0x05FF:
r = 0; g = 191; b = 255;
break;
case 0x967F:
r = 145; g = 206; b = 250;
break;
case 0x07FF:
r = 0; g = 255; b = 255;
break;
case 0x471A:
r = 64; g = 224; b = 208;
break;
case 0x067A:
r = 0; g = 206; b = 209;
break;

// Shades Of Green
case 0x8400:
r = 128; g = 128; b = 0;
break;
case 0x9E66:
r = 154; g = 205; b = 50;
break;
case 0x7FE0:
r = 124; g = 252; b = 0;
break;
case 0x0400:
r = 0; g = 128; b = 0;
break;
case 0x3666:
r = 50; g = 205; b = 50;
break;
case 0x07E0:
r = 0; g = 255; b = 0;
break;
case 0x9FD3:
r = 152; g = 251; b = 152;
break;

// Shades of Orange and Yellow
case 0xFA80:
r = 250; g = 80; b = 0;
break;
case 0xFC60:
r = 255; g = 140; b = 0;
break;
case 0xFD20:
r = 255; g = 165; b = 0;
break;
case 0xDD24:
r = 218; g = 165; b = 32;
break;
case 0xFEA0:
r = 255; g = 215; b = 0;
break;
case 0xFFE0:
r = 255; g = 255; b = 0;
break;
case 0xF731:
r = 240; g = 230; b = 140;
break;

// Shades of Purple and Pink
case 0x895C:
r = 138; g = 43; b = 226;
break;
case 0x8010:
r = 128; g = 0; b = 128;
break;
case 0x8811:
r = 139; g = 0; b = 139;
break;
case 0xBABA:
r = 186; g = 85; b = 211;
break;
case 0xF8B2:
r = 255; g = 20; b = 147;
break;
case 0xF81F:
r = 255; g = 0; b = 255;
break;
case 0xFB56:
r = 255; g = 105; b = 180;
break;

// Shades of Brown
case 0x8A22:
r = 139; g = 69; b = 19;
break;
case 0xA285:
r = 160; g = 82; b = 45;
break;
case 0xD343:
r = 210; g = 105; b = 30;
break;
case 0xF52C:
r = 244; g = 164; b = 96;
break;
case 0xD5B1:
r = 210; g = 180; b = 140;
break;
case 0xF6F6:
r = 245; g = 222; b = 179;
break;
case 0xFF38:
r = 255; g = 228; b = 196;
break;

// Shades of Black and White
case 0x0000:
r = 0; g = 0; b = 0;
break;
case 0x630C:
r = 96; g = 96; b = 96;
break;
case 0x8410:
r = 128; g = 128; b = 128;
break;
case 0xC618:
r = 192; g = 192; b = 192;
break;
case 0xD69A:
r = 211; g = 211; b = 211;
break;
case 0xDEFB:
r = 220; g = 220; b = 220;
break;
case 0xFFFF:
r = 255; g = 255; b = 255;
break;

default:
Serial.print(“Error in showPixelsWithColor() switch statement\nColor is: “);
Serial.print(color);
break;
}

// Display the color of the neopixel stick
for(int i=0;i<NUMPIXELS;i++) {
pixels.setPixelColor(i, pixels.Color(r,g,b));
pixels.show(); // This sends the updated pixel color to the hardware.
}
Serial.print(“Changed neopixel color to: “);
Serial.print(color);
Serial.print(“\nR, G, B: “);
Serial.print(r);
Serial.print(“, “);
Serial.print(b);
Serial.print(“, “);
Serial.print(g);
Serial.print(“\n”);
}

void turnPixelsOff() {
//Set the neo pixels to off to begin with!
for(int i=0;i<NUMPIXELS;i++) {
pixels.setPixelColor(i, pixels.Color(0,0,0));
pixels.show(); // This sends the updated pixel color to the hardware.
}
}
void displayLogo() {
tft.setCursor(65, 100);
tft.setTextColor(ILI9341_WHITE); tft.setTextSize(5);
tft.println(“Novo”);
tft.setCursor(50, 150);
tft.setTextColor(ILI9341_WHITE); tft.setTextSize(5);
tft.println(“Aduro”);
}

void createBoxes(int delayval = DELAYVAL) {
//First Row
for(int i = 0; i < ROWS; i++) {
tft.fillRect(BOXSIZE*i, 0, BOXSIZE, BOXSIZE, shadesOfRed[i]);//xywh
delay(delayval);
}

//Second Row
for(int i = 0; i < ROWS; i++) {
tft.fillRect(BOXSIZE*i, BOXSIZE, BOXSIZE, BOXSIZE, shadesOfGreen[i]);//xywh
delay(delayval);
}

//Third Row
for(int i = 0; i < ROWS; i++) {
tft.fillRect(BOXSIZE*i, BOXSIZE*MULTIPLIER_2, BOXSIZE, BOXSIZE, shadesOfBlue[i]);//xywh
delay(delayval);
}

//Fourth Row
for(int i = 0; i < ROWS; i++) {
tft.fillRect(BOXSIZE*i, BOXSIZE*MULTIPLIER_3, BOXSIZE, BOXSIZE, shadesOfOrangeAndYellow[i]);//xywh
delay(delayval);
}

//Fifth Row
for(int i = 0; i < ROWS; i++) {
tft.fillRect(BOXSIZE*i, BOXSIZE*MULTIPLIER_4, BOXSIZE, BOXSIZE, shadesOfPurpleAndPink[i]);//xywh
delay(delayval);
}

//Sixth Row
for(int i = 0; i < ROWS; i++) {
tft.fillRect(BOXSIZE*i, BOXSIZE*MULTIPLIER_5, BOXSIZE, BOXSIZE, shadesOfBrown[i]);//xywh
delay(delayval);
}

//Seventh Row
for(int i = 0; i < ROWS; i++) {
tft.fillRect(BOXSIZE*i, BOXSIZE*MULTIPLIER_6, BOXSIZE, BOXSIZE, shadesOfBlackAndWhite[i]);//xywh
delay(delayval);
}

//Eighth Row (Special Effects)
for(int i = 0; i < ROWS; i++) {
tft.drawRect(BOXSIZE*i, BOXSIZE*MULTIPLIER_7, BOXSIZE, BOXSIZE, allShades[0][i]);//xywh
tft.setCursor(BOXSIZE*i+18, BOXSIZE*MULTIPLIER_7+14);
tft.setTextColor(ILI9341_WHITE); tft.setTextSize(2);
tft.println(i+1);
delay(delayval);
}
}
void setup(void) {

Serial.begin(9600);
Serial.println(F(“Touch Paint!”));

pixels.begin(); // This initializes the NeoPixel library.
tft.begin();

if (!ts.begin()) {
Serial.println(“Couldn’t start touchscreen controller”);
while (1);
}
Serial.println(“Touchscreen started”);

tft.fillScreen(ILI9341_BLACK);
//displayLogo();
//delay(1000);
createBoxes(0);
turnPixelsOff();

//showPixelsWithColor(shadesOfBlackAndWhite[5]);

}
void loop() {

// See if there’s any touch data for us
if (ts.bufferEmpty()) {
//displayLogo();
return;
}

// // You can also wait for a touch
// if (! ts.touched()) {
// return;
// }

Serial.print(“touchscreen touched!”);

// Retrieve a point
TS_Point p = ts.getPoint();

Serial.print(“X = “); Serial.print(p.x);
Serial.print(“\tY = “); Serial.print(p.y);
Serial.print(“\tPressure = “); Serial.println(p.z);

// Scale from ~0->4000 to tft.width using the calibration #’s
p.x = map(p.x, TS_MINX, TS_MAXX, 0, tft.width());
p.y = map(p.y, TS_MINY, TS_MAXY, 0, tft.height());

//tft.fillCircle(p.x, p.y, 10, ILI9341_RED);//p.x, p.y, PENRADIUS, currentcolor

Serial.print(“(“); Serial.print(p.x);
Serial.print(“, “); Serial.print(p.y);
Serial.println(“)”);

pixels.setBrightness(100);

if (p.y < BOXSIZE) {
if (p.x < BOXSIZE) {
showPixelsWithColor(shadesOfRed[0]);
} else if (p.x < BOXSIZE*2) {
showPixelsWithColor(shadesOfRed[1]);
} else if (p.x < BOXSIZE*3) {
showPixelsWithColor(shadesOfRed[2]);
} else if (p.x < BOXSIZE*4) {
showPixelsWithColor(shadesOfRed[3]);
} else if (p.x < BOXSIZE*5) {
showPixelsWithColor(shadesOfRed[4]);
} else if (p.x < BOXSIZE*6) {
showPixelsWithColor(shadesOfRed[5]);
}
} else if (p.y < BOXSIZE*2) {
if (p.x < BOXSIZE) {
showPixelsWithColor(shadesOfGreen[0]);
} else if (p.x < BOXSIZE*2) {
showPixelsWithColor(shadesOfGreen[1]);
} else if (p.x < BOXSIZE*3) {
showPixelsWithColor(shadesOfGreen[2]);
} else if (p.x < BOXSIZE*4) {
showPixelsWithColor(shadesOfGreen[3]);
} else if (p.x < BOXSIZE*5) {
showPixelsWithColor(shadesOfGreen[4]);
} else if (p.x < BOXSIZE*6) {
showPixelsWithColor(shadesOfGreen[5]);
}
} else if (p.y < BOXSIZE*3) {
if (p.x < BOXSIZE) {
showPixelsWithColor(shadesOfBlue[0]);
} else if (p.x < BOXSIZE*2) {
showPixelsWithColor(shadesOfBlue[1]);
} else if (p.x < BOXSIZE*3) {
showPixelsWithColor(shadesOfBlue[2]);
} else if (p.x < BOXSIZE*4) {
showPixelsWithColor(shadesOfBlue[3]);
} else if (p.x < BOXSIZE*5) {
showPixelsWithColor(shadesOfBlue[4]);
} else if (p.x < BOXSIZE*6) {
showPixelsWithColor(shadesOfBlue[5]);
}
} else if (p.y < BOXSIZE*4) {
if (p.x < BOXSIZE) {
showPixelsWithColor(shadesOfOrangeAndYellow[0]);
} else if (p.x < BOXSIZE*2) {
showPixelsWithColor(shadesOfOrangeAndYellow[1]);
} else if (p.x < BOXSIZE*3) {
showPixelsWithColor(shadesOfOrangeAndYellow[2]);
} else if (p.x < BOXSIZE*4) {
showPixelsWithColor(shadesOfOrangeAndYellow[3]);
} else if (p.x < BOXSIZE*5) {
showPixelsWithColor(shadesOfOrangeAndYellow[4]);
} else if (p.x < BOXSIZE*6) {
showPixelsWithColor(shadesOfOrangeAndYellow[5]);
}
} else if (p.y < BOXSIZE*5) {
if (p.x < BOXSIZE) {
showPixelsWithColor(shadesOfPurpleAndPink[0]);
} else if (p.x < BOXSIZE*2) {
showPixelsWithColor(shadesOfPurpleAndPink[1]);
} else if (p.x < BOXSIZE*3) {
showPixelsWithColor(shadesOfPurpleAndPink[2]);
} else if (p.x < BOXSIZE*4) {
showPixelsWithColor(shadesOfPurpleAndPink[3]);
} else if (p.x < BOXSIZE*5) {
showPixelsWithColor(shadesOfPurpleAndPink[4]);
} else if (p.x < BOXSIZE*6) {
showPixelsWithColor(shadesOfPurpleAndPink[5]);
}
} else if (p.y < BOXSIZE*6) {
if (p.x < BOXSIZE) {
showPixelsWithColor(shadesOfBrown[0]);
} else if (p.x < BOXSIZE*2) {
showPixelsWithColor(shadesOfBrown[1]);
} else if (p.x < BOXSIZE*3) {
showPixelsWithColor(shadesOfBrown[2]);
} else if (p.x < BOXSIZE*4) {
showPixelsWithColor(shadesOfBrown[3]);
} else if (p.x < BOXSIZE*5) {
showPixelsWithColor(shadesOfBrown[4]);
} else if (p.x < BOXSIZE*6) {
showPixelsWithColor(shadesOfBrown[5]);
}
} else if (p.y < BOXSIZE*7) {
if (p.x < BOXSIZE) {
showPixelsWithColor(shadesOfBlackAndWhite[0]);
} else if (p.x < BOXSIZE*2) {
showPixelsWithColor(shadesOfBlackAndWhite[1]);
} else if (p.x < BOXSIZE*3) {
showPixelsWithColor(shadesOfBlackAndWhite[2]);
} else if (p.x < BOXSIZE*4) {
showPixelsWithColor(shadesOfBlackAndWhite[3]);
} else if (p.x < BOXSIZE*5) {
showPixelsWithColor(shadesOfBlackAndWhite[4]);
} else if (p.x < BOXSIZE*6) {
showPixelsWithColor(shadesOfBlackAndWhite[5]);
}
} else if (p.y < BOXSIZE*8) { //SPECIAL EFFECTS
if (p.x < BOXSIZE) {
colorWipe(pixels.Color(255, 0, 0), 2);//red
colorWipe(pixels.Color(0, 255, 0), 2);//blue
colorWipe(pixels.Color(0, 0, 255), 2);//green
turnPixelsOff(); //TURN OFF!
} else if (p.x < BOXSIZE*2) {
theaterChase(pixels.Color( 0, 0, 127), 2); // Blue
theaterChase(pixels.Color( 0, 127, 0), 2); // green
theaterChase(pixels.Color( 127, 0, 0), 2); // red
turnPixelsOff();
} else if (p.x < BOXSIZE*3) {
rainbow(2);
turnPixelsOff();
} else if (p.x < BOXSIZE*4) {
rainbowCycle(2);
turnPixelsOff();
} else if (p.x < BOXSIZE*5) {
theaterChaseRainbow(2);
turnPixelsOff();
} else if (p.x < BOXSIZE*6) {
colorWipe(pixels.Color(139, 0, 139), 2);
colorWipe(pixels.Color(255, 20, 147), 2);
turnPixelsOff();
}
}
}//end loop

3D Printing Experience

I attended the 3D printing show April 17. I didn’t think I was going to enjoy it the way I did. Since it was the last day it wasn’t as packed so I got to view all most of the 3D printing. This was great experience for me because I have never been proposed to things like this. The show was a new world to me. I am mostly familiar with car shows or fashion shows and to be expose to the 3D printing world was refreshing. One of my favorite 3D printing was the Arctec Group Shapify. There printing solely focuses on creating real human faces and body structure and to see some of the examples were really authentic. I also thought it was pretty cool how there 3D printing work. They would take a a human being and have them standing in this cylinder and something would rotate around them until they captured every party of the human body and then they printed it out. It could be any part of the human body. My other favorite 3D printing company I don’t remember the name, I think their lack of not having an actual 3D printer there for showcase had to do with it. But all of there 3D models were made out of heavy medal. All of there objects were heavy and hard which I thought was interesting because I didn’t know 3D printing can create heavy medal products. Even though I don’t have the name I do have videos and pictures of the object. I gave some of the 3D printing companies my email so they can email me more information on there 3D printing and other shows available in New York City that I would be interested in.

Arctec Group Shapify photos

 

image image image image

 

The heavy metal 3D Printing

image

 

Other videos and photos from the 3D printing conference

image image image image image image image image image image

MSHP Final

Hey guys, recently I learned how to use an Arduino for High Speed Flash Photography. The person whose work inspired me is a creative technologist Matt Richardson.
I see someone using this project when they are outdoors trying to capture something moving very quickly. Photographers will definitely love my project. Or anyone who is interested in taking high speed photos. But I am really making this project so that I can take photos at high speed.
Intended audience are people who walks into a room or someone who is moving very quickly and is captured without motion blur. For instance, during my presentation I set up my project behind a studio set in a dark room and
people were interested in what went on behind there. As students and faculties entered the room and the flash triggered which caused the camera to take a picture. Some were annoyed by the flash firing. Others were purposely walking in front of the camera just so that they can have their picture taken. Others thought it was creepy that their picture is being taken. My project didn’t have anything to touch or speak into so as people approach my project, the flash would fire. However, I ran into a slight problem on the day of my presentation. Although everything was connected to the Arduino, something went wrong with the wring because the Arduino only communicated with the motion sensor and camera. What went wrong ? I could not figure that out. But I did end up dismantling me presentation to do some troubleshooting. That didn’t work out so great. I just knew to myself that something went wrong in the wiring. But needless to say, the project didn’t completely fall apart. The actual interactions were not 100% what I was expecting, but it did fulfill a portion of my proposal. I hoped that the moment the motion sensor detects movement, it will trigger the flash to take a photo. But like I mentioned preciously, I happen to find fault in the project which took me by surprise because I thought it was ready to go.
Based upon interactions from others, I would make this project more accessible to all users. Run more tests to be more certain that the project works and also be more prepared for when failure takes place. Many people wondered why the project didn’t fully do what it was meant to do. And so I explained its purpose and why I was inspired to choose the project. My response was simple. The project is made to take a photo when someone moves and some people thought …. Hmm ok. That’s it? Then I added, and after the picture is taken, the picture would be presented on a TV screen. That also didn’t work out because of technical difficulties. Rather than using a standard SD card, for the purpose of recontexualizing the whole idea, I purchased a flash air SD card. The flash air SD was meant to have its own wifi service and connect to a Mac which would present the image by using it i airplay mode. I think if that had actually been fulfilled, my project would have made much more sense. Would I say my project did not worked as intended due to all the mishaps? I’d rather say it needed more tests to run before I made a presentation.
In addition to my presentation, there were some materials that were all meant to make sense. The only materials that were really used for this project were the camera mounted onto a tripod, a one way mirrored box which held the camera inside. The sensor that caused the camera to fulfill its purpose and an Arduino UNO to make this all possible. In Richardson video, his bill of materials were simple.
This project is fixed. The only thing I would suggest is to run further testing before you put everything together. Just to make sure it works correctly and how you program it to work.
The way I made this project my own would be by creating an old vintage look and presenting each image of someone walking by onto a tv screen. In a way it’s unique because I think a lot of people would have been surprised to see their photo and at the same time, they would have enjoyed it more. As for the code, it took forever for me to figure it all out. In fact, I didn’t fully understand codes. Especially the ones we needed to find for this final project. All I knew was that I wanted my camera to take a picture and show it up on a screen but putting the codes for all of that at once, just turned this whole project into something more complex Han what it originally was. With some help and a lot of research, the code became more clear to me. And that’s when I came up with a crazy idea to combine codes.
The building process wasn’t so bad. It only took me within a day to put the whole thing together. The tripod does not count because it is already made for use. However, many people complimented my design.
I used the Arduino IDE and programming language for this project.
The code is where all of the communication between Arduino and object takes place. In this project it is the Arduino,camera, motion sensor and external flash. This code is meant to calibrate with the motion sensor that tells the camera something is moving, fire the flash and take a picture.

/* Audio camera trigger by Matt Richardson
This is a basic sound-detecting camera & flash trigger for Arduino.
Use a piezo element for the sensor (see http://www.arduino.cc/en/Tutorial/KnockSensor)
Use opto isolators (aka optocouplers) for the flash and camera triggers
Camera must be in BULB mode for shutter release to work


*/

#define BUTTON_PIN 5
#define CAM_TRIGGER_PIN 11
#define FLASH_TRIGGER_PIN 12
#define Pir_Pin 3     //the digital pin connected to the PIR sensor’s output
#define STANDBY 3
#define ACTIVE 1
#define SENSOR_THRESHOLD 3

int calibrationTime = 30;

//the time when the sensor outputs a low impulse
long unsigned int lowIn;

//the amount of milliseconds the sensor has to be low
//before we assume all motion has stopped
long unsigned int pause = 5000;

boolean lockLow = true;
boolean takeLowTime;

int mode = STANDBY;

// For best results, set flashDelayMS according to what type
// of shot you’re doing. 3 seems best for balloon burst while
long flashDelayMS = 10;

void setup() {
pinMode(BUTTON_PIN, INPUT);
pinMode(CAM_TRIGGER_PIN, OUTPUT);
pinMode(FLASH_TRIGGER_PIN, OUTPUT);
pinMode(Pir_Pin, OUTPUT);
Serial.begin(9600);
pinMode(Pir_Pin, OUTPUT);
digitalWrite(Pir_Pin, LOW);

Serial.print(“calibrating sensor “);
for(int i = 0; i < calibrationTime; i++){
Serial.print(“.”);
delay(1000);
}
Serial.println(” done”);
Serial.println(“SENSOR ACTIVE”);
delay(50);
}

void loop()
{
if (digitalRead(BUTTON_PIN) == HIGH)

{if(digitalRead(Pir_Pin) == HIGH)
{
if(lockLow)
//makes sure we wait for a transition to LOW before any further output is made:
lockLow = false;
Serial.println(“—“);
Serial.print(“motion detected at “);
Serial.print(millis()/1000);
Serial.println(” sec”);
delay(50);
}

if(digitalRead(Pir_Pin) == LOW)
{

if(takeLowTime){
lowIn = millis();        //save the time of the transition from high to LOW
takeLowTime = false;       //make sure this is only done at the start of a LOW phase
}
//if the sensor is low for more than the given pause,
//we assume that no more motion is going to happen
if(!lockLow && millis() – lowIn > pause){
//makes sure this block of code is only executed again after
//a new motion sequence has been detected
lockLow = true;
Serial.print(“motion ended at “);     //output
Serial.print((millis() – pause)/1000);
Serial.println(” sec”);
delay(50);
}
}
}

{
mode = ACTIVE;
delay(2000); // to give time for light to go down and settle after button push
digitalWrite(CAM_TRIGGER_PIN, HIGH); // open the camera shutter
}
if ((mode == ACTIVE) && (analogRead(Pir_Pin) > SENSOR_THRESHOLD)) //
{ //If we’re in ACTIVE mode and we sense a pop:
delay(flashDelayMS);
digitalWrite(FLASH_TRIGGER_PIN, HIGH); // fire flash
delay(50);
digitalWrite(FLASH_TRIGGER_PIN, LOW);
digitalWrite(CAM_TRIGGER_PIN, LOW); // close camera shutter
mode = STANDBY;
}
}


Many people complimented the work. Some people suggested that I take out the flash. Others suggested that I take the photo in black and white that way it doesn’t look as bad since the flash was not firing.

The presentation was not so bad. But I was able to troubleshoot an error slightly by connecting the external flash to the camera using the hot shoe.
I haven’t really used any other languages to interface with Arduino, but I did combine codes for the sensor, for the camera and the flash to communicate with each other to snap a picture.
Some tools that are needed are as follows:
Solder
Soldering iron
Wire cutter /stripper

Bill of Materials Prepared by Matt Richardson:
Arduino Nano v3.0
Opto-isolator: Panasonic AQW280EH
Piezo element: Radio Shack 273-059
Hot shoe to PC Sync adapter: Hama HA-6950
PC Sync Cable
Power-switch Tail Relay: Ada-fruit sells them with some useful extras!
Jumper wire: these or these.
Solder-less breadboard
Resistors: 4.7K for current limiting to Opto-isolator, 1M for the Piezo
Pushbutton
My Bill of Materials:
Arduino UNO
Breadboard
Jumper wires
Connectors
Resistors: 4.7K for current limiting to Opto-isolator
Pc sync cable
Hot shoe adapter: B&H
Canon: T3i EOS
flash air by toshiba
Pushbutton
For Presentation:
Tripod
One way mirrored box
Mac
Apple TV

I would say I put in a lot of time and troubleshooting to get this project up and working. So that the results would be that not just a person’s picture gets taken but also anything that moves and the sensor captures it, can have a picture taken.
My expected build time was way too long. It surprise me how much time I really thought I would put into this project. The estimated time this project I thought would take was approximately, 672 hours. Fortunately it just took a few days to figure out the right code, put together the schematics. Testing took less time but I do believe it needed more time just because I would not have been disappointed for my presentation.
Some of the project’s dimensions were the fact that the flash did not fire which caused me to try connecting it directly to the camera.
I would say this project is dependent only because it needs a software and code to be uploaded for the motion sensor to complete calibrating, flash to fire and camera to take a photo.
One thing that would prompt or guide a user to interact with the project is walking by and seeing a bright flash firing and seeing their photo presented on a TV screen.

Final Reflection

A few things this class thought me or something I am leaving with after the semester are learning to approach a project in real world. I see this as a big challenge because I am used to creating applications in a different programming environment. Luckily for me arduino is a native language any one that is used to programming will easily understand arduino IDE. Functions, variables, naming convention etc are common in any programming language. This is my first time working with software and hardware together. Usually what ever I develop stays somewhere online. You see it but you can’t touch it. This class was more hands-on (less coding and more building with your hands and being very creative. I have seen some cool projects online or on the street and I always wonder how they created it. I have always wanted to create something cool like that but due to lack of resources or no dedicated time, I procrastinate on the project and it will end up being just a forgotten memory. My final project was a belt and lights up. As plain and simple that sounds, there is more to it than just being a belt that lights up. The concept is to have a pulse sensor connected to an arduino, then the arduino gets whatever digital value that comes in from the pulse sensor and outputs it to the led which in turns lights up the leds. The first challenge I had was how to be very creative about the project. As my professor says “how can you make this project yours, your own unique DNA” (something like that). I am used to going with client’s guidelines or requirements when creating an applications. Except in this class I am re-contextualizing someone else’s work or idea. As I said earlier, I am not very creative. At first I didn’t know what I wanted to do, I have a pulse sensor and a led strip. Sure, it reads bpm and lights up, but how can I make it interesting? I went online and saw projects people were doing with this arduino. I came up with the idea of a life bar from the game DEADSPACE. The first problem I had in creating the life bar was that no one ever created it with an arduino. People made a full suite (I hope to make mine) someone even turned their cpu into a real life bar meter (only works on pc). I was inspired but at the same time no code exist to create this lifebar with arduino so I had to take a step back and look at my materials. The pulse sensor have its own code but most examples were using “dumb leds” I again went online and I saw other people created projects but nothing close to what I wanted. Next problem was understanding how to program the led strip. The company I brought it from had a lots of projects created and how to create those projects but nothing close to what I wanted. I downloaded their sample lights displays to understand how the codes works or how to program it to what I wanted it for. I finally figured out the codes for both materials, now it is time to combine them together. No clue what I was doing at first. In the pulse sensor they have a place where you will trigger the leds but I am using a smart led. Anyways I will pass the trigger for smart leds here. To my surprise it works, it triggered the leds. I was excited to at least see it working. Now to set the colors I need with the pulse sensor. After hours of creating color codes for the led strip. I gave it a test, it works but freezes after the first read value from the arduino. I asked my self what I did wrong. I checked the codes again and again but I couldn’t figure out the problem. My mistake before changing the code, I could have posted the question in a forum for help. I ended up having to use only two colors (red and black color) for the pulse reading. I used red color when the pulse sensor gets any reading follow by a black color to turn the red off simultaneously. Looking back from when I first started the class, I never thought I will be able to create anything as cool and creative like my pulse sensor belt. Now I have the confident that I can make more projects I come across online or even my own ideas. I also learn to manage project time better. If I am to do this project over, It will probably take at most 2 days.

LINK TO MY CODES AND HOW TO GUIDE.

Final Project Post: Monochron Clock Box

In the beginning of this course I already knew it was going to be my most challenging because it was the first time I was doing something hands on working with software and studios and physically building projects. But I knew if I put my time into it I would be okay. My final project is a monochron clock. An idea I got from many different users on the web who made a monochron clock. I was misguided by the idea of what the monochron clock did at first. I originally thought it was something of a game but then I later found out the seconds in the time was just used in a game play format. I got the idea from a couple YouTube videos.

I still ordered the monochron clock because I wanted to change it to different time zones instead of one. What inspired my project was my interest in clocks. Plus I had no better idea to think about at the time. I couldn’t find the original creators of the monochron clock. It’s been utilized many diferent ways by many different people. This is a clock, so I would imagine that it can be intended for everyone. I had a few people ask me the exact same question “what does it do” and I told them all the same thing. Everyone needs to know the time. I would adjust my project by soldering a USB input on to the arduino so I would’ve been able to connect it to the computer so I can hack it. Another adjustment I would add is putting the the monochron clock inside of a plexiglass instead of a a box. My project didn’t work as I intended. I wanted to solder a USB onto it so I would be able to hack it on the computer but it didn’t come with one. The materials and components that I use worked up to a certain extent. Because I spent way much money than I intended to I was eager to build it and make it my own. However I didn’t spend enough time on it to make it unique. I spent more time just trying to figure out how to work it than what to build it in and that’s where I went wrong. I didn’t get to use the code because I couldn’t hook it up to the computer. The coding that I was suppose to use was suppose to make the clock write out my name and tell other time. I’ll show the coding later on in this post. I used comments off of YouTube and comments from makezine and adafruit to help me. I didn’t troubleshoot or debug anything with my project because it wasn’t able to hook up to the computer without a USB. The tool that I had to use while building this project was solder, soldering iron, helping hands, razor, cutter, I used a computer to help guide me through the step process. When I first started I was excited to see the end result. I think mostly because I paid so much for the clock kit I was really motivated to get my project done right. But during it I admit that I did give up a little and ran out of time and got frustrated with the whole thing. My output was that I did what I could’ve done. The last thing I was trying to do was get a plexiglass but there were none in any stores I search. If I was to order it, it would’ve taken a lot longer to get here. Even after the deadline of this post. My expected time to finish this whole project was 72 hours. 3 days, 72 hours of committed work I think I would have been done on time. But unfortunately other priorities get in the way of that. I definitely lesrned something from my experience with this class. Anything you want to make or do you have to make sure you have all the right tools, organized and put in the right amount of time or more.

Bill of Materials https://learn.adafruit.com/monochron/parts-list

Links:

https://learn.adafruit.com/monochron/preparation

https://learn.adafruit.com/monochron/solder-it

http://timewitharduino.blogspot.com/2011/01/introducing-wise-clock-3.html

https://123led.wordpress.com/about/

http://www.adafruit.com/products/204

 

 

image

image image image image image image image image image image image image image image image image
image imageimage image image image image image image image image image image image image image