Safe Cracker Part 4 Hardware Polish: (Final Project) Michael Frankfort & Jill Sauer

After the code was mostly complete, and the images were filled with temporary place holder art, it was finally time to get the hardware into a permanent state. I found that the box that the Arduino and components came in had a very sturdy base and could be adapted to sufficiently hold the hardware. In order to mount all of the buttons, the tilt sensor, the buzzer and the LED’s, a few hours of ingenuity and effort were required. To mount the button, I borrowed a perforated board from my roommate, and stuck the push buttons onto the board. Using a dremmel, I cut out three square holes on the top of the box and hot glued the perfboard to the underside of the box lid. For the LED’s that indicate whether an action is correct or incorrect, I made 2 small dremmel holes so that the leads of the LED’s went inside of the box and the LED heads stuck on top of the lid. A large hole was then cut out of the side of the box in order to allow the USB cable to connect into the Arduino. Finally, I used the breadboard’s built in adhesive to stick it permanently to the bottom of the box while carefully rewiring and positioning the Arduino inside of the box to limit movement. A picture of the final hardware design can be found below.

Safe Cracker Part 3 The Code: (Final Project) Michael Frankfort & Jill Sauer

After all of the electronics and hardware were essentially complete, it was finally time to start on the logic of the safe cracking through C code in processing. In general, the simulation plays as follows: Players are in a warehouse and arrive at a safe they need to crack. Luckily for them, they brought specific step by step directions to follow on a scrap piece of paper. The player must execute each move correctly in a row in order to move onto the next part of the safe. In the three given “levels” of cracking the safe, the players will interface with various buttons, all while rotating their device to the correct orientation. If a player gets a sequence wrong, they will lose all progress on that level and must restart form the beginning. The main problem with failure on the levels is that there is a global timer that ticks down quite quickly. Since you are robbing the facility at night, it is important that you make your escape before daylight. If the player cannot traverse the directions on all three levels within the time limit, they will be “caught” and have to start the game all over again. The code to implement all of this functionality was actually complicated and verbose. I ended up having to store all of the correct moves within special arrays, track the users current moves in lists, all well polling the hardware to see its’ current pin orientation. Complications arose when users rotated the device; the tilt sensor would receive many values very quickly, which would confuse the game logic into thinking that a player acted incorrectly when in reality they performed the correct maneuvers. Many added delays, timers and Boolean variables had to be implemented so that the hardware worked as smoothly as the software. Below is a placeholder screenshot of in-game footage that describes the above.

Safe Cracker Part 2: (Final Project) Michael Frankfort & Jill Sauer

Once my sketch was compiled, and I could get the blinking built in LED on my Arduino board to interface with my processing sketch, it was then time to build actual circuits. The kit I received came with multiple sensors, most notably, a tilt sensor, 5 push buttons and a piezo buzzer. In order to hook up all of the circuits, I found all of the schematics online, which thankfully came with somewhat documented Arduino tutorials to show how to connect each of the devices. The first step I learned how to accomplish was to set up power for the entire board. I ran a red wire form the 5v power supply on the Arduino board to my breadboard, and followed that up with connecting another red wire from GND on the Arduino to GND on the breadboard. Once that was setup, it was finally time to hook up the first push button. Following given tutorials on the Arduino website, I found an example sketch in the processing library that checks the input of all the pins on the Arduino and was able to register a button press on the Arduino from processing! Once the first button was created, the next two followed suit and finally I had all three buttons on my breadboard fully implemented. The next two components, the tilt sensor, and the buzzer were relatively the same circuit setup. The only difference between the implementing the buttons and the tilt sensor/buzzer is simply the code needed to activate and deactivate the triggers. The tilt sensor works by moving a ball inside of a black box, where once the ball makes a connection with the side of the box, it completes the circuit making the pin go high. For the buzzer to be active for a set period off time, the implementing code must have a manual digital write to the accompanying pin to cut the connection and stop the buzzer. A completed circuit with all of the sensors and buttons added can be seen below!

Safe Cracker Part 1: (Final Project) Michael Frankfort & Jill Sauer

Last Friday, I had received all of the Arduino components in the mail, that is both the Arduino Uno board and the given components had finally shipped after a few weeks in transit. After opening the package, I found the first step to start the new project would defiantly require assembly. I found out rather quickly that I had no explicit knowledge in creating circuits, so in order to hook up many of the buttons and sensors that came with the kit, it was necessary for me to start some technical research. Below is a general idea of what parts came with the Arduino kit:

After some more technical research I came to the conclusion that in order to control my Arduino board from processing, it was necessary to download a specific library and install it into the correct folder. I then found out that the actual Arduino IDE which is used to interface with the Arduino board alone has an example sketch that can be used right out of the box to serially connect with other devices so that no code has to be running on the Arduino side while the processing sketch is being executed. After setting up the correct libraries, I attempted to compile the given code but was faced with some errors. The first error I received was the fact that serial connections could not be made in the 64 bit version of processing. After some simple google searching, I found the easiest solution was to merely download the 32 version of processing. After completion of the above steps, I tried to compile the processing code, however I was met with another error that prevented me from interfacing with my Arduino board. The error was very obscure and after some more extended google searching, I found a bizarre hotfix on github that seemed to fix the bug. Finally, after completing all the installation steps, the sketch finally compiled and I could use a simple script in processing to blink the built in LED on pin 13.

Final Project Idea, Michael Frankfort

The concept for my final project stems from auditory, visual, and reflexive sensitivity. The general idea is inspired by classic reaction and memory based games such as “Simon says”, “Bop-it”, and “Twister,” and will use an arduino uno board as means of communication with the user. The arduino board will be hooked up with a series of sensors including a tilt sensor, an alarm-like buzzer, and three colored LEDs accompanies by 4 push buttons. Attached to the arduino board will be an A to B USB cable connecting it to a computer running processing. The user will interact with the arduino board in three different ways which will be dictated in real time in processing. The three different ways of interaction will actually be different games which are explained below:

Interaction one, color matching: The computer running processing will show a series of lights that must be pressed using the button attached to the LEDs on the arduino. Players must press the buttons in the correct order in the allotted time to gain completion credit for the activity.

Interaction two, sound differentiation: The processing sketch will play a series of tones, some of which will be important, and some of which will not. The sound that the buzzer makes on the arduino must be matched with the sounds the user hears during the playback. The player must count the correct number of buzzer sounds and press the corresponding button based on the amount of times the buzzer noise was produced.

Interaction 3, tilt feedback: Processing will display an image, which at any point will flip on the screen. Immediately, the user must flip the tilt sensor before a set timer runs out.
The following interaction will be incorporated into a fluent game, where players will gain lives by successfully completing a series of challenges in a row, and lose lives if they do not complete a challenge correctly. Finally, the entire project will be based around the idea that video games in fact do have redeeming qualities. As the player completes certain challenges, a graphical image of the user will be drawn on screen next to the game logic which will animate in a way to show the user gaining memory and reaction time throughout playing with the project.

Plan:
A simple path to follow in order to do the necessary research for this project will include:
1) Research the necessary libraries to incorporate arduino feedback in processing
2) Researching how to play auditory sounds through processing
3) Researching methods to hook up the necessary sensors to the arduino, as well as registering input of the sensors into processing

Technical Flow:
In order to put the entirety of the project together, I will need to split up the work into three main categories: art, software, and hardware. The artistic aspect of the project will include making all of the 2D graphics such as the in game icons, animation of the player, and instructions. The software portion must entail the overall state machine of the game, registering input from the arduino, and programming the arduino to perform its’ own actions such as turning on an LED or alarming a buzzer. The final hardware portion will be setting up the physical circuit of the arduno in order to successfully communicate with the board through processing.

Idea 2:

Another idea I have thought up which is a little bit less ambitious is a “stealth robbery simulator” which tracks the player’s sneakiness while navigating a virtual warehouse. Players must walk very slowly and silently in order to successfully complete their thievery. The actual setup of the device is as follows: Users will wear a baseball cap with an arduino board attached to the side. Mounted on the brim of the cap is a flat plate where a tilt sensor will be secured in order to maintain a flat surface. The user must watch a computer screen which will be showing a processing sketch with a barely visible room outline. As the player starts the simulation, they must walk in a straight line without tilting the sensor too much. During the activity, the screen will start to become brighter as the occupants of the warehouse seem to noises. At this point the music that was playing lightly in the background will start to increase in volume and the screen will become brighter simulating flashlights. At this point the sensor will be more prone to fail the player as they must be extra quiet to not alarm the guards. Finally if the player makes it through the “night” before getting caught, they will have successfully completed the mission. If at any point they trigger the sensor too much, a buzzer will go off signaling the guards and the player’s failure of the mission.

Project 2 Hypnotic Style (Michael Frankfort)

For the second project, we were asked to create a mixed video, containing external input, with a focus on portrayal of internet memes. My interpretation of the project specifications brought me to comment on the most recent pop culture craze, Gangnam Style by Psy. In general, I feel that most pop music is made popular through incredibly catchy rhythms and a steady beat, and in this case, Gangnam Style is no exception. The first time I listened to Korea’s most popular song, I became almost hypnotized with the overarching melody, so I wanted to make a Pure Data patch that reflected this as closely as possible.

I started off by using some of the links in class to get the music video of Gangnam Style, along with a hypnotic spiral also found on Youtube. As I learned in class, the actual .wav of the music video had to be extracted separately because pure data doesn’t play the accompanied sound when using the video mixing objects. After importing all of the video and music files, I used the patch to mix two separate videos together as a starting point. I then took the simple sound recorder patch in order to load the Gangnam style .wav file. However when loading the file for some reason the music was played in 2x speed, which made the video and music completely out of sync. I found another tutorial on youtube that imported files a different way in order to try and alleviate the problem. However even after this modification, the file still played in 2x speed. After much research, I found out that Pure Data does not interpret files over a certain capacity, and will try to compress to music in anyway possible. In order to fix the issue, I took the music file, cut out most of the chorus, and edited the music video to match.

After finally getting the music and video to be in sync, I realized that every time I closed the patch, I had to load the files and press about ten different toggle switches in the right order all to get the components working correctly. After a little more research, I found the load bang object which would preset all of my data so that the entire patch could be played just by opening the gem window. To complete the input device portion of the project, I took an Xbox360 controller and wrote a subpatch to get all of the input from the device. I really wanted to change the pitch of the audio in realtime using the controller but it seemed that there was no built in object that could be placed before the dac~ object. Luckily there was a tutorial on how to create such a patch from a preexisting pure data example, which I modified in order to fit into my main patch.

At this point I had my left joystick controlling the pitch of the audio, (as well as the mixing between my two music videos), and my right joystick controlling the phaser, which is a built in audio plugin that creates a reverberation effect. Finally I wanted a way to incorporate transmission of information from Processing to Pure Data. In order to satisfy this, I created a random number generator inside the draw function of my processing patch. I then changed the frame rate so that it would send a value to pure data once per second. Finally I took this value, did some math operations and plugged those values into a delay object which creates a small echo effect randomly in the audio which is more heavily weighted when the hypnotic video is more defined.

This project in general introduced me into many new pure data objects as well as the powerful effect that can occur when linking two different programs together that both have different strengths. Below is a link to a video I made of the patch in action:
http://youtu.be/58u2kSjGoj0

Blogging assignment 2, French Pavilion La Biennale 2011

For my Interactive Qualifying Project in Venice Italy, my team and I went to this grand art exhibition known as the Venice Biennale. Inside the exhibition were countries from all around the world who brought really talented artists to construct both electronic and interactive artwork. I remember almost a year ago visiting the French Pavilion and seeing one of the most incredible works of interactive art that really captured the attention of everyone in the room. The installation was titled “chance” and had pictures of newborn faces on old style film that was sent all throughout a main room through tracks of scaffolding. In the adjacent room were two counters, the current birth rate and the current death rate in the entire world. Here is a link to a video that our team actually took while we were there: https://www.youtube.com/watch?feature=player_embedded&v=LHkjUUgfqsw

By far the most successful part of the exhibit was the shear size of the installation. The track which ran all of the film filled the entire room and really gave the exhibit a “worldly” scale which really went in line of the overall message of the piece, which was that the whole world is really interconnected from birth. From the get go, the installation held your attention due to the fast moving parts, loud volume, and maze like structure that the exhibition goers had to navigate to reach the next room. The reason why the artwork was so compelling stemmed from the fact that birth, and the chance that you could be born in any part of the world is completely relate-able. Most people at one point or another in their lives have thought what it would have been like to be born in another part of the world, with a new appearance, and new style of living. A great aspect of this work is that it’s completely extensible. This same structure could be applied to many other social issues such as world hunger rates, or awareness of diseases. To see more about this exhibit you can check out this full length video: http://www.youtube.com/watch?v=47o10W_ltVc

Project 1 – Hurricane

The final sketch of the three part series of this project features inspiration from the most recent storm, hurricane Sandy. However, the difference is in this sketch is I’ve created a mini game which allows the user to try and thwart the hurricane as it reaches the coastline. The players must control the hurricane with the four arrow keys, and direct the storm into the targets displayed on screen. If the hurricane hits all of the targets before reaching the end of the shoreline, the storm will perform a shrinking animation signalling the player has won, and restart the game. If the player misses the targets, the game will restart. In order to build suspense, the size of the hurricane grows as each target is collected until finally it reaches critical mass where the player either wins or loses. You can play the game below!

Project 1 – Electricity

For the second sketch the Machine vs. Nature project series, my main inspiration was electricity! After seeing an example in class about how to create noise within a line, it sparked some great ideas on how to create an interactive Van der Graaf generator. The user can control the “power level” of the machine by using the up and down arrow keys. As the power level rises, random sparks of electricity in the background become more frequent. In addition, more lines of electricity form at power levels 5 and 10. Finally, the thickness of the electricity changes along with the color the more powerful the machine gets. Check out the machine below!

Project 1 – Snowflake

In general, for the first project “Nature vs. Machine” I took a very literal approach to creating the forces of nature in each of my three sketches. The first one, titled snowflake, is sketch that features a snowy day with uniquely behaving snowflakes. Each snow flake was created by a separate sketch that is modified from one of the spiral examples shown in class. The images created are then loaded into the main sketch which features falling snowflakes on a snowy background. When the snowflakes fall, they check collisions with all of the other snowflakes around them. If two flakes collide, one of them will be deleted and the remaining snowflake will absorb the size of the disappearing snowflake. The remaining snowflake also changes hue, until it reaches the bottom of the screen. As the sketch is played, the flakes become larger and larger due to the settings of the sketch. The viewer will notice that eventually the screen will be covered in large snowflakes that simulate a growing snow storm. Although for some strange reason the version, when posted on the website, does not change the colors of the snowflakes.