Evan's Blog

Just another Web Publishing @ NYU site

Archives for December 2023

Laser Security System – Evan – Eric Parren

CONCEPTION AND DESIGN:

This is an interactive game based on laser dodging, where laser emitters are fixed to the walls on both sides or to the cardboard overhead. Players need to avoid the laser lines and get to the end without triggering the alarm to press the pass button and get the diamond at the end.

(movie: Ocean Twelve)

Originally conceptualized as the “Laser Breakout Challenge,” this project aimed to create an interactive gaming experience by manipulating laser direction through a top projector. The idea was to immerse players in an environment where they’d dodge dynamically controlled laser lines. However, technical limitations in motion capture using the projector led to a pivot in design. The evolved “Laser Security System” transformed the space by suspending 80cm x 80cm cardboard panels from the ceiling, crafting an immersive challenge that deviated from the initial concept but maintained its essence.

The pivot from the projector-based concept to the suspended cardboard panels was a significant design adaptation. The decision to use Arduino sensors, particularly light-dependent resistors (LDRs), was pivotal. These sensors provided accurate detection of laser contacts and formed the backbone of the system’s functionality. Additionally, the incorporation of 3D-printed fixtures and a motorized mechanism for the rotating green laser further enriched the interactivity of the system, compensating for the earlier envisioned dynamic projector control.

Not only these lasers, but I also chose to add rgb led pixel around the passage to create a tense atmosphere. rgb flashes in the direction from the start to the end, and I also added a red and blue light element above the head, similar to the blinking of a police light, which flashes red and blue to simulate an alarm when the challenger is detected. I’ve also added a buzzer, which will also work together.

Electronic Diagrams

FABRICATION AND PRODUCTION:

The fabrication process involved suspending the 80cm x 80cm cardboard panels from the ceiling, creating an expansive and engaging play area. The implementation of Arduino sensors, specifically the LDRs, showcased the project’s technical ingenuity. Initially, the concept involved a top projector for laser control, but the technical constraints prompted a more hands-on approach, leading to the suspension of lasers for a tangible interactive experience.

All the materials I used:  Thanks to Eric’s suggestion, I was able to use a ping pong ball on the outside of the idr to extend the sensing area, which proved to be very successful.

The main Arduino parts:

  Moving laser:

Observing user reactions and responses during user testing provided us with valuable insights. Based on user feedback, the alert system was modified and more storytelling elements were added, such as the need for the challenger to reach the finish line to get the diamonds, rather than simply passing through a laser-filled tunnel. I also added black cloth at the start and in the middle to cover and stop the smoke from spreading out. This creates a more immersive and enjoyable experience.

What the tunnel looks like:   

The selection of 3D-printed fixtures for laser mounting and the intricate motorized mechanism for the rotating green laser represented innovative solutions to achieve the desired interactivity. While the initial concept had projected the lasers for control, this adaptation allowed for physical engagement, enhancing the game’s dynamic without compromising its immersive quality.

Since the smoke created by the fog machine has a very unpleasant odor, I have a mask for the challenger as a way to ward off the smoke and have a more immersive experience as well.

Also, I wrote “paint what you want” & “be respectful” on one of the walls.
I also wrote “paint what you want” & “be respectful” on one of the walls. I originally wanted to use this as a way to spruce up my program and give everyone in the ima faculty a chance to vent and relax as they prepare for final, but surprisingly, it was more successful than I could have imagined. I have witnessed so much art being born on this, each with their unique ideas and leaving their work here. I think this section has elevated my work to a higher level and it’s only more of a place to reflect our ima creativity.

Pictures form user testing & IMA Show

Video form user testing & IMA Show

 

CONCLUSIONS:

From the genesis of the “Laser Breakout Challenge” to the eventual realization of the “Laser Security System,” this journey has been a testament to adaptability and problem-solving in the face of technical challenges. As a solo endeavor, the project demanded creative solutions and a flexible approach to overcome unexpected limitations.

Despite the solitary nature of the project, the “Laser Security System” managed to exceed initial expectations, offering an immersive and engaging experience that encapsulated the spirit of the envisioned game.

The “Laser Security System” started differently but ended up surprising us all! It turned into this awesome game that really captured what we wanted. The road wasn’t easy- I faced challenges that made us think differently. Instead of holding me back, those challenges helped me grow. I went from just knowing the tech stuff to being super resourceful and flexible. This project taught me that obstacles can actually push me forward. It gave me skills and ideas I know I’ll use in my future projects. I’m excited to bring this innovative and resilient attitude to whatever comes next!

DISASSEMBLY:

It’s really hard for me to dismantle my project because it’s so much of my work and it’s so unique.😭😭😭

APPENDIX:

My code for the overpass animation in processing:

import processing.video.*;

Movie myMovie;
boolean isPlaying = false; 

void setup() {
  fullScreen();
  myMovie = new Movie(this, "Congratulations.mp4");
}

void draw() {
  if (isPlaying && myMovie.available()) {
    myMovie.read();
  }
  image(myMovie, 0, 0, width, height);
}

void keyPressed() {
  if (!isPlaying) { 
    myMovie.play();
    isPlaying = true;
  }
}

void movieEvent(Movie m) {
  m.read();
}

video: https://www.youtube.com/watch?v=b5BuMr9K8Ck

code for alert system:
#include <Adafruit_NeoPixel.h>
#define PIN 6
int Pixels = 60;
const int buzzerPin = 12;
const int ldrPin0 = A0;
const int ldrPin1 = A1;
const int ldrPin2 = A2;
// const int ldrPin3 = A3;
Adafruit_NeoPixel strip = Adafruit_NeoPixel(Pixels, PIN, NEO_GRB + NEO_KHZ800);
void redFlash()
{
red(strip.Color(255, 0, 0), 100); //call Red function – pass it color and delay values
red(strip.Color(0, 0, 0), 0); //Turn off all pixels
delay(100);
red(strip.Color(255, 0, 0), 100); //repeat
red(strip.Color(0, 0, 0), 0);
} //end redFlash
void blueFlash()
{
blue(strip.Color(0, 0, 255), 100); //call blue function – pass it color and delay values
blue(strip.Color(0, 0, 0), 0); //Turn off all pixels
delay(100);
blue(strip.Color(0, 0, 255), 100); //repeat
blue(strip.Color(0, 0, 0), 0);
} //end blueFlash
void red(uint32_t c, uint8_t wait) //passed color (c) and delay (wait) values
{
int i = 0; //start at pixel 0
while (i < Pixels/2) //loop until you reach half the pixels
{
strip.setPixelColor(i, c); //sets the pixel and color
i++;
}
strip.setBrightness(156); //sets the pixel brightness
strip.show(); //turns on the pixels
delay(wait); //wait designated time (wait)
} //end red
void blue(uint32_t c, uint8_t wait) //passed color (c) and delay (wait) values
{
int i = Pixels+1; //start at the last pixel
while (i > Pixels/2-1) //loop until you reach half the pixels
{
strip.setPixelColor(i, c); //sets pixel and color
i–;
}
strip.setBrightness(255); //sets brightness
strip.show(); //turns on pixels
delay(wait); //wait designated time (wait)
} //end blue
void setup () {
Serial.begin(9600);
pinMode(buzzerPin, OUTPUT);
pinMode(ldrPin0, INPUT);
pinMode(ldrPin1, INPUT);
pinMode(ldrPin2, INPUT);
strip.begin();
strip.show(); //Initilize strip to all off
}
void loop() {
int ldrStatus0 = analogRead(ldrPin0);
int ldrStatus1 = analogRead(ldrPin1);
int ldrStatus2 = analogRead(ldrPin2);
if (ldrStatus0 > 500 || ldrStatus1 > 300 || ldrStatus2 > 400) {
tone(buzzerPin,100);
redFlash(); //call redFlash function
delay(100);
blueFlash(); //Call blueFlash function
delay(100);
noTone(buzzerPin);
delay(100);
}
else {
noTone(buzzerPin);
}
Serial.print( ldrStatus0 );
Serial.print(“,”);
Serial.print( ldrStatus1 );
Serial.print(“,”);
Serial.print( ldrStatus2 );
Serial.println();
}
code for flashing RGB:
#include <FastLED.h>
#define DATA_PIN 3
#define NUM_LEDS 60
#define BRIGHTNESS 32
CRGB leds[NUM_LEDS];
unsigned long currentMillis;
unsigned long previousMillis;
unsigned int timeDelay = 50u; //50mS delay between LED updates
int pulseLength = 8; //number of LEDs in a pulse
byte onOff = 0;
void setup() {
// FastLED.addLeds<WS2812B, DATA_PIN, RGB>(leds, NUM_LEDS);
FastLED.addLeds<NEOPIXEL, DATA_PIN>(leds, NUM_LEDS);
LEDS.setBrightness(BRIGHTNESS);
}
void loop() {
currentMillis = millis();
if ((currentMillis – previousMillis) >= timeDelay) {
previousMillis = currentMillis;
//this randomly starts a new pulse about 1 % of the time for test purposes
if (random(50) == 25) {
onOff = 1;
}
reactLEDStrip();
}
}
void reactLEDStrip () {
static byte pulseIn = 0; //LED pulse to feed into the start of the LED strip
if (onOff == 1) { //check to see if a new pulse needs to be started
pulseIn = pulseLength; //set length of pulse to feed into LED strip
onOff = 0;
}
for (int i = NUM_LEDS – 1; i > 0; i–) { //start at end of LED strip and work towards start
if ((leds[i – 1].r || leds[i – 1].g || leds[i – 1].b) == 0x00) { //check to see if LED is turned off (all colors set to 00)
leds[i] = leds[i – 1]; //if LED is turned off, shift it up one position
} else {
leds[i] = CRGB::Red; //if LED is not turned off, set it to a new random color while shifting up one position
}
}
if (pulseIn == 0) {
leds[0] = CRGB(0, 0, 0); //turn off first LED if not feeding in a new pulse
} else {
leds[0] = CRGB::Red; //if feeding in a new pulse, set first LED to random color
pulseIn–; //update number of LEDs left in the current pulse
}
FastLED.show();
}