Final Project Introduction:


  • Describe your concept

I aimed to delve into recreating a retro game named “Feed Flynn,” blending the Catcher and spaceship Tyrian games into one fun experience. Inspired by the saying “don’t eat the book” and my deep fondness for food, I wanted to craft a game celebrating my love for food—an arcade-style creation I call “Feed Flynn.”

You get points for Feeding Flynn donuts +10,

Burgers ( full Meal ) + 20

Books -3 (why would you even feed Flynn Books ;( )

Flynn also has the ability to shoot bullets to eliminate the books. It’s a 35-second challenge to compete for the highest score, a way to test your skills and challenge your friends for the top spot!

The game adopts a retro vibe with:

  • A glitchy character sprite
  • Pixelated character design
  • Incorporation of music and sound effects
  • Include some pictures / video of your project interaction

this is how my project hardware is looking ( retro arcade)

I decided to have my single line of instruction Do NOT eat the books on the box; Condensing complex rules into concise, clear instructions often enhances comprehension and user engagement

  • How does the implementation work?
    • Description of interaction design

Interaction design involves creating the interface between a user and a system, aiming to optimize the user’s experience. In the context of “Feed Flynn,” the game utilizes four arcade buttons to facilitate the player’s interaction:

      • Start/Restart Button: This button initiates the game or restarts it once it’s over. It serves as the gateway to engage with the game, allowing the player to enter the gaming experience.
      • Right/Left Buttons: These two buttons enable the movement of Flynn, the character, within the game. They provide directional control, allowing Flynn to navigate right or left within the gaming environment, dodging falling objects or positioning to catch desired items.
      • Bullet Firing Button: This button empowers Flynn to shoot bullets in the game. By pressing this button, players can eliminate books, preventing them from being consumed by Flynn and avoiding point deductions. It adds an element of strategy and skill to the gameplay, requiring players to decide when to fire bullets strategically.
      • Description of Arduino code and include or link to full Arduino sketch
    • const int buttonStartPin = 2;   // Pin for the start button
      const int buttonLeftPin = 3;    // Pin for the left button
      const int buttonRightPin = 4;   // Pin for the right button
      const int buttonFirePin = 5;    // Pin for the fire button
      void setup() {
        pinMode(buttonStartPin, INPUT_PULLUP);
        pinMode(buttonLeftPin, INPUT_PULLUP);
        pinMode(buttonRightPin, INPUT_PULLUP);
        pinMode(buttonFirePin, INPUT_PULLUP);
      void loop() {
        int startButtonState = digitalRead(buttonStartPin);
        int leftButtonState = digitalRead(buttonLeftPin);
        int rightButtonState = digitalRead(buttonRightPin);
        int fireButtonState = digitalRead(buttonFirePin);
        // Invert button states before sending to serial
        delay(100); // Optional delay to stabilize readings


      • Description of p5.js code and embed p5.js sketch in post
  • let catcherX, catcherY; // Declaring variables for catcher position
    let objects = []; // Array to store falling objects
    let objectSpeed; // Variable to control object speed
    let gameStarted; // Flag to track game state
    let serial; // Serial port communication variable
    let points; // Variable to track player points
    let startTime; // Start time of the game
    let gameDuration; // Duration of the game
    let fireButtonState = 0; // State of the fire button
    let bullets = []; // Array to store bullets
    let backgroundImage; // Variable to hold a background image
    let backgroundImage2; // Another background image variable
    let backgroundImage3; // Third background image variable
    let catcherFrames = []; // Array to store frames of the sprite sheet
    let catcherIndex = 0; // Index to track the current frame
    let catcherSpeed = 0.2; // Speed of the catcher animation
    var gif; // Variable for a GIF element
    let catchSound; // Sound variable for catching objects
    function preload() {   // Loading assets
      backgroundImage = createImg("");
      backgroundImage2 = loadImage("2.png");
      backgroundImage3 = loadImage("6.png");
      bungeeFont = loadFont('Bungee-Regular.ttf');
      catcherSheet = loadImage('8.png');
      books = loadImage("3.png");
      donut = loadImage("4.png");
      burger = loadImage("5.png");
      gif = createImg("");
        gameStartSound = loadSound('07. STAGE 2 [PC Engine]-1.mp3');
      gameOverSound = loadSound('33. GAME OVER [PC-9801]-1.mp3');
      catchSound = loadSound('heavy_swallowwav-14682.mp3');
     // Setup canvas and initial game conditions
    function setup() {
      createCanvas(889, 500);
      catcherX = width / 2;
      catcherY = height - 50;
      objectSpeed = 2;
      gameStarted = 0;
      points = 0;
      gameDuration = 35; 
      startTime = millis();
      serial = new p5.SerialPort();'COM6'); 
      serial.on('data', serialEvent);
    // Game loop managing different game states
    function draw() {
      if (gameStarted === 0 ) {
        // Display the appropriate background image 
            if (!gameStartSound.isPlaying()) {
      } else if (gameStarted === 1) {
        image(backgroundImage2, 0, 0, width, height);;
      gif.position(catcherX - 100, catcherY - 60);
        // Draw catcher and game elements
    // Function handling the core game logic and rendering
    function drawGame() {
      let currentTime = millis();
      let elapsedTime = (currentTime - startTime) / 1000; // Elapsed time in seconds
      let remainingTime = gameDuration - floor(elapsedTime); // Remaining time in seconds
      text(`Time: ${remainingTime}`, width - 80, 52);
      // Draw catcher
      ellipseMode(CENTER); // Set ellipse mode to CENTER
      catcherX = constrain(catcherX, 25, width - 25);
      ellipse(catcherX, catcherY, 50, 50); // Draw a circle for the catcher
      // Generate falling objects continuously
      if (frameCount % 30 === 0) {
      // Draw falling objects
      for (let obj of objects) {
        obj.y += objectSpeed;
        // Check for catch
        if (
          obj.y > catcherY - 10 &&
          obj.y < catcherY + 10 &&
          obj.x > catcherX - 25 &&
          obj.x < catcherX + 25
        ) {
      // Display points
      text(`Points: ${points}`, 170 , 50);
      // Handle bullets
      // Check for game over
      if (millis() - startTime >= gameDuration * 1000) {
    // Handling keyboard input for catcher movement
    function keyPressed() {
      const catcherSpeed = 5;
      if (keyCode === LEFT_ARROW) {
        catcherX -= catcherSpeed;
      } else if (keyCode === RIGHT_ARROW) {
        catcherX += catcherSpeed;
    // Handling serial port events for game control
    function serialEvent() {
      let data = serial.readLine();
      if (data !== null) {
        let states = data.split(',');
        let startButtonState = parseInt(states[0]);
        let leftButtonState = parseInt(states[1]);
        let rightButtonState = parseInt(states[2]);
        fireButtonState = parseInt(states[3]);
        const catcherSpeed = 10;
        if (startButtonState === 1) {
          if (gameStarted !== 1) {
            gameStarted = 1;
            points = 0; // Reset points to zero when the game starts
            startTime = millis();
        if (gameStarted) {
          if (leftButtonState === 1) {
            catcherX -= catcherSpeed;
          } else if (rightButtonState === 1) {
            catcherX += catcherSpeed;
    // Generating falling objects
    function generateObjects(numObjects) {
      let generatedObjects = [];
      for (let i = 0; i < numObjects; i++) {
        let type;
        let rand = random();
        if (rand < 0.2) {
          type = 'square';
        } else if (rand < 0.6) {
          type = 'circle';
        } else {
          type = 'triangle';
        let obj = {
          x: random(width),
          y: random(-50, -10),
          type: type,
      return generatedObjects;
    // Drawing and displaying falling objects
    function drawObject(obj) {
      if (obj.type === 'triangle') {
        ellipse(obj.x, obj.y, 30, 30); 
        image(books, obj.x - 45, obj.y - 35, 90, 55); 
      } else if (obj.type === 'circle') {
        ellipse(obj.x, obj.y, 30, 30); 
        image(donut, obj.x - 39, obj.y - 22.5, 80, 45); 
      } else if (obj.type === 'square') {
        ellipse(obj.x - 10, obj.y - 10, 30, 30); 
        image(burger, obj.x - 60, obj.y - 45, 100, 60); 
    // Handling catcher interaction with falling objects
    function handleCatch(obj) {
      if (obj.type === 'triangle') {
        points -= 3;
      } else if (obj.type === 'circle') {
        points += 10;
      } else if (obj.type === 'square') {
        points += 20;
      }; // Play the sound when the catcher catches an object
      objects.splice(objects.indexOf(obj), 1);
      // Handling bullet mechanics
    function handleBullets() {
      if (fireButtonState === 1) {
        bullets.push({ x: catcherX, y: catcherY });
      for (let i = bullets.length - 1; i >= 0; i--) {
        let bullet = bullets[i];
        bullet.y -= 5;
        fill(255, 0, 0);
        ellipse(bullet.x, bullet.y, 5, 10);
        for (let j = objects.length - 1; j >= 0; j--) {
          let obj = objects[j];
          if (dist(bullet.x, bullet.y, obj.x, obj.y) < 15 && obj.type === 'triangle') {
            objects.splice(j, 1);
            bullets.splice(i, 1);
            points += 5;
        if (bullet.y < 0) {
          bullets.splice(i, 1);
      // Displaying the game over screen
    function displayGameOver() {
      // Display game over screen
      image(backgroundImage3, 0, 0, width, height);
      console.log("Game Over");
      text("Game Over", width / 2, height / 2 - 90) ;
      text(`Your Score: ${points}`, width / 2, height / 2 );
      gameStarted = 2;
    • Describtion of the code:
    • Variables: Various variables are declared to manage game elements such as catcher position, falling objects, game state, time, sound, and image assets.
    • preload(): Preloading assets like images, sounds, and fonts before the game starts.
    • setup(): Initializing the canvas size, setting initial game conditions like catcher position, object speed, and game duration, as well as initializing the serial port communication.
    • draw(): The main game loop that manages different game states and calls specific functions based on the game state.
    • drawGame(): Handles the core game logic and rendering. Manages time, displays game elements, generates falling objects, checks for collisions, and handles points and game over conditions.
    • keyPressed(): Listens for keypress events to control the catcher’s movement.
    • serialEvent(): Handles events from the serial port for game control (button presses, etc.).
    • generateObjects(): Generates falling objects of different types (triangle, circle, square).
    • drawObject(): Draws and displays the falling objects based on their types (triangle, circle, square) using images.
    • handleCatch(): Manages the interaction between the catcher and falling objects, updating points and removing caught objects.
    • handleBullets(): Handles the bullet mechanics, allowing the catcher to shoot at falling objects, awarding points upon successful hits.
    • displayGameOver(): Displays the game over screen, stops game sounds, shows the final score, and resets game states.
      • Description of communication between Arduino and p5.js

At first, I struggled a lot with understanding serial communication. It was hard, and it made it tough to communicate well for the project. But when I asked for help and used the p5 .exe desktop app better, things got easier. Learning how to use it properly helped me improve how I communicated for the project.

  • What are some aspects of the project that you’re particularly proud of?

I’m really happy with the graphics! Being a graphic designer, I put a lot of effort into creating Flynn and the game design. It was super fun to work on this video game, and I don’t think it’ll be my last! This time around, I loved playing with pixels, making animations, and exploring different pixel art styles for that cool retro theme.

I also noticed a visual connection between my Midterm Game “CatsAway” and this project. Both have this joyful vibe and a surreal feel, especially flying around and munching on books, which is part of my art style.

  • What are some areas for future improvement?

Accessibility: I’m aiming to ensure the game is accessible to a wider audience by making it compatible across different devices or platforms. This improvement will make the game available to more players, which is a goal I’m focused on.


Final Project Proposal: Feed Flynn

I. Introduction

“Feed Flynn” is an immersive and engaging arcade-style game designed to entertain and challenge players. This game combines intuitive arcade button controls with a visually appealing graphic design ( which I designed YALL) to create an enjoyable gaming experience.

Some pictures:

Figure 1: My little Retro Style Flynn

Figure 2: My Game logo

II. Project Overview

A. Concept

The game revolves around Flynn, the main character, navigating through a world filled with edible objects and obstacles. The primary objective is to maneuver Flynn using arcade buttons, collecting burgers and donuts for points while avoiding collision with books, which results in point deductions. Flynn also has the ability to shoot bullets to eliminate books, adding an element of strategy and focus to the gameplay.

B. Features

  1. Arcade-Style Controls: Utilize physical or on-screen arcade buttons to move Flynn left and right within the game environment.
  2. Score System: Accumulate points by collecting burgers and donuts while avoiding collisions with books. Each successful collection adds points, while collisions deduct points.
  3. Shooting Mechanism: Implement Flynn’s ability to shoot bullets to eliminate books, allowing players to strategically clear obstacles.

Final project proposal

For my final project I propose to transform the conventional game ‘The Mole’ by incorporating force sensors into an Arduino setup. My goal is to enhance gameplay by introducing a tangible, hands-on interaction using force-sensitive sensors. I envision players engaging with a physical setup, detecting and responding to varying force levels to navigate through game challenges. By fusing classic gameplay with sensor technology, I aim to create an immersive and innovative gaming experience that redefines interaction in gaming environments. This project represents my aspiration to merge traditional entertainment with modern tech, offering players a novel way to engage with ‘The Mole.

I am excited

week 11- reading reflectiom – design meets disability

This book about the collaboration between the Eameses and their creation of leg splints for veterans is a profound exploration of how design transcends its conventional boundaries. What’s truly fascinating is their approach—they didn’t just aim for practicality in their design; they sought to blend functionality with aesthetic appeal.

What’s really interesting is how deeply they considered the human aspect. The Eameses didn’t limit their focus to the technicalities; they delved into the emotional and experiential dimensions of their design. They wanted these splints to not only serve their purpose but also uplift the users’ spirits, ensuring comfort and a sense of dignity.

Their emphasis on inclusive design is remarkable. They didn’t want these splints to be exclusive; they envisioned them as tools accessible to all, irrespective of abilities. It’s a profound statement about the importance of ensuring good design is available universally.

The core message resonating here is that design isn’t just about appearances; it’s about functionality and the impact it has on people’s lives. The Eameses’ venture with these leg splints is a testament to how empathetic design can significantly enhance lives and contribute to a more equitable and inclusive society.

Series Connection


In this assignment, I worked with Fady John to achieve the three exercises in class

Exercise 1:

p5 js

let left = 0;

function setup() {
  createCanvas(400, 400);

function draw() {
  ellipse(left, 50, 50, 50);

function keyPressed() {
  if (key == " ") {
    // important to have in order to start the serial connection!!

function readSerial(data) {
  left = map(data, 0, 1023, 0, 400);


//// Arduino Code

void setup() {
  // put your setup code here, to run once:


void loop() {
  // put your main code here, to run repeatedly:
  int sensor = analogRead(A0);



Exercise 2:

P5 js

let brightnessSlider;
let brightnessValue = 0;

function setup() {
  createCanvas(400, 200);

  // Create a brightness slider
  brightnessSlider = createSlider(0, 255, 128);
  brightnessSlider.position(width/2-50, height/2);'width', '100px');

function draw() {

  // Get the brightness value from the slider
  brightnessValue = brightnessSlider.value();

function keyPressed() {
  if (key == " ") {
    // important to have in order to start the serial connection!!

function readSerial(data) {
    let dataToSend = brightnessValue + ", \n";


///Arduino COde

const int ledPin = 9;  // Digital output pin for the LED

void setup() {
  pinMode(ledPin, OUTPUT);

  // Start serial communication

void loop() {
  // Check if data is available from p5.js
  if (Serial.available() > 0) {
    // Read the brightness value from p5.js
    int brightness = Serial.parseInt();

    // Map the received value to the LED brightness range
    brightness = constrain(brightness, 0, 255);

    // Set the LED brightness
    analogWrite(ledPin, brightness);


Exercise 3:

P5 js

let velocity;
let gravity;
let position;
let acceleration;
let wind;
let drag = 0.99;
let mass = 50;
let led = 0;

function setup() {
  createCanvas(640, 360);
  position = createVector(width/2, 0);
  velocity = createVector(0,0);
  acceleration = createVector(0,0);
  gravity = createVector(0, 0.5*mass);
  wind = createVector(0,0);

function draw() {
  if (position.y > height-mass/2) {
      velocity.y *= -0.9;  // A little dampening when hitting the bottom
      position.y = height-mass/2;
  if(position.y == height-mass/2 && (velocity.y > 0.5 || velocity.y < -0.5)){ 
    led = 1;
    led = 0;

function applyForce(force){
  // Newton's 2nd law: F = M * A
  // or A = F / M
  let f = p5.Vector.div(force, mass);

function keyPressed(){
  if (key == "n") {
    // important to have in order to start the serial connection!!
  if (key==' '){
    mass=random(15, 80);

function readSerial(data) {

  if (data != null) {
    // make sure there is actually a message
    // split the message
    wind.x = data;

    //SEND TO ARDUINO HERE (handshake)
    let sendToArduino = led + "\n";


///Arduino COde


int ledPin = 9;

void setup() {
  // Start serial communication so we can send data
  // over the USB connection to our p5js sketch
  pinMode(ledPin, OUTPUT);

void loop() {
  int sensor = analogRead(A0);
  int wind = map(sensor, 0, 1023, -2, 2);
  if (Serial.available() > 0) {
    // Read the brightness value from p5.js
    int touch = Serial.parseInt();
    // Set the LED brightness
    digitalWrite(ledPin, touch);


exercise3 week11

Noctune Noir Week 10

Group Members: Batool Al Tameemi, Arshiya Khattak

Concept: For this project, we knew we wanted to implement something piano-esque, i.e. pressing buttons and implementing different sounds. Essentially, it is a simple Arduino circuit that uses three buttons and a buzzer, playing a note every time a button is pressed. However, we wanted to make the concept a little more fun, so we decided to add a photocell (it was also a cool way to add more notes than just 3). When the photocell is uncovered, the buttons play higher frequency notes (A flat, G, and F) and when it’s covered, it plays lower frequency sounds (D, C, and B). The idea is in daylight the keys play more upbeat-sounding tones, while at night they make more sombre-sounding noises.

Video & Implementation


TinkerCad Diagram:

The code for this project was relatively straightforward. The frequency equivalent in Arduino for the notes were taken from this article.

int buzzPin = 8;
int keyOne = A1;
int keyTwo = A2;
int keyThree = A5;
int lightPin = A0;
int brightness = 0;
int keyOneState, keyTwoState, keyThreeState;

int flexOneValue;

void setup() {

void loop() {
  brightness = analogRead(lightPin);
  keyOneState = digitalRead(keyOne);
  keyTwoState = digitalRead(keyTwo);
  keyThreeState = digitalRead(keyThree);
  if (brightness < 45) {
    if (keyOneState == HIGH) {
      // tone(buzzPin, 262);
      playTone(587); //D flat
    } else if (keyTwoState == HIGH) {
      playTone(523); //C
    } else if (keyThreeState == HIGH) {
  } else {
    if (keyOneState == HIGH) {
      // tone(buzzPin, 1000, 400);
      playTone(831); //A
    } else if (keyTwoState == HIGH) {
      playTone(784); //G
    } else if (keyThreeState == HIGH) {

void playTone(int frequency) {
  int duration = 200;
  tone(buzzPin, frequency, duration);

Future Highlights and Improvements

One thing that we both thought would be cool to implement on a longer form of this project would be to have different levels of brightness play different notes, rather than just having two states. It would also be cool to incorporate different forms of input, such as the flex sensor (we tried to use it but it was a bit buggy so we scrapped the idea).

Reading reflection week 10

A breif Rant on the Future of interactive media

The reading on future interfaces was mind-blowing! It was like someone suddenly turned on a light in a room I’d been sitting in for ages, and suddenly, everything made sense in a completely new way.

The author of this reflection, wow, they had been in the thick of designing future interfaces. Real prototypes, not just concepts. That’s a level of hands-on experience few people get. It’s like being backstage at a magic show and seeing how the tricks are really done.

Their beef with the video wasn’t about nitpicking interactions but about the vision itself. It wasn’t bold enough, not enough of a leap from the mess we’re dealing with in the present. And I get that! Visions should inspire, not just be a ho-hum “yeah, that’ll do” kind of thing.

But what really hit me was the talk about our hands. Hands are amazing! I mean, we use them constantly, but do we ever really think about how intricate they are? They’re like the Swiss Army knives of our bodies. Feeling things, manipulating objects—our hands are our interface with the world.

The idea of “Pictures Under Glass” really got to me. It’s like we’re willingly giving up the richness of touch for the sake of a fancy visual. The comparison to tying shoelaces with closed eyes hit home. We’re prioritizing sight over touch, but in reality, touch is the real MVP in how we interact with things.

The rant about the gestures we use with our fingers blew my mind. The fact that we switch between different grips without even thinking about it—opening a jar, for instance—showed how intuitive our interactions really are. Our hands are built for a three-dimensional world, for manipulating objects in ways that no other creature can. It’s like a superpower we take for granted every day!

And the call to action at the end was so powerful. The future isn’t predetermined; it’s a choice. It’s up to us to push for better interfaces, ones that harness the full potential of what our bodies can do. Why settle for a single finger when we have this incredible body that can do so much more?

What do I think about the Follow up

It’s like the author just dropped a knowledge bomb and left me reeling with thoughts and arguments ricocheting around my head.

The responses they received were a mix of understanding and misconceptions. The author wasn’t seeking to solve the problem outright; they wanted to spark curiosity and inspire researchers to delve into unexplored territories. The idea was to lay down the issue and hope it would catch the eye of the right people who could initiate the necessary research. That’s a pretty bold move!

The analogy about technology evolution using Kodak’s camera was spot on. The iPad, like the black-and-white camera, is groundbreaking, but it’s clear something’s missing. The push should be towards a dynamic tactile medium, not just a flat, glassy screen with minimal haptic feedback.

Their take on voice interfaces was refreshing. While acknowledging the importance of voice, especially for certain tasks, they stressed the limitations when it comes to creation and deep understanding. Explorable environments, where you can physically manipulate things, seem like the real deal.

The exploration of gestural interfaces was intriguing. From discrete abstract gestures to waving hands in the air, each had its pros and cons, but none seemed to fully harness the potential of our hands and bodies in a three-dimensional world.

The part about brain interfaces hit hard. Why are we trying to bypass our bodies altogether? It’s like saying our bodies are inadequate for the digital age. It’s a bold reminder to adapt technology to suit our natural capabilities rather than forcing ourselves to adapt to it.

The quote about fingertips and their importance for development resonated deeply. It’s like saying if we don’t use certain faculties, we lose them. The comparison to limiting literature to Dr. Seuss for adults is both humorous and thought-provoking.

And the clever redirect about the length of the rant with the book recommendation at the end was a nice touch!

Digital and Analog


So I was thinking of how I could make something creative enough to pass this assignment vibes check so I thought of photocell ( which is digital) and a Tactile push button ( which is analog ) to light up my cute little car,

You know how it is when you’re driving in the dark – you need those headlights on, and when you want to change lanes, you’ve gotta give a signal. That’s exactly what I wanted to mimic.

So, when it gets dark, my little car’s headlights kick in with the help of two LEDs, and if I want to switch lanes, I just press that button, and the LEDs start blinking to signal my lane change. Cool, right.

Materials I used:
  1. Arduino board (e.g., Arduino Uno)
  2. 2 LEDs (green)
  3. 2 x 220-ohm resistors (for current limiting)
  4. Tactile push-button switch
  5. Photocell (Light-dependent resistor, LDR)
  6. 10k-ohm resistor (for voltage divider)
  7. Breadboard and jumper wires


if its not THAT clear from the pic:

  • I connected a jumper wire from the ground (GND) rail on the breadboard to the GND (ground) pin on the Arduino.
  • I then connected a jumper wire from the 5V rail on the breadboard to the 5V pin on the Arduino.
  • I then connect another jumper wire from the 5V rail on the breadboard to the row where the side of the photocell connected to 5V is placed.
  • Finally I used a jumper wire to connect the other side of the photocell to the same row as the 10k-ohm resistor’s other end.
const int led1Pin = 8;           // Define a constant integer variable for the pin of the first LED.
const int led2Pin = 9;           // Define a constant integer variable for the pin of the second LED.
const int buttonPin = 2;         // Define a constant integer variable for the pin of the tactile button.
const int photocellPin = A0;     // Define a constant integer variable for the pin of the photocell sensor.

int led1State = LOW;              // Initialize an integer variable to store the state of the first LED as LOW.
int led2State = LOW;              // Initialize an integer variable to store the state of the second LED as LOW.
int buttonState = LOW;            // Initialize an integer variable to store the state of the tactile button as LOW.
int lastButtonState = LOW;        // Initialize an integer variable to store the previous state of the button as LOW.
int lightValue = 0;               // Initialize an integer variable to store the light reading from the photocell.
int threshold = 500;              // Set a threshold value for the light reading. You can adjust this value based on your environment.

void setup() {
  pinMode(led1Pin, OUTPUT);        // Set the pin of the first LED as an OUTPUT.
  pinMode(led2Pin, OUTPUT);        // Set the pin of the second LED as an OUTPUT.
  pinMode(buttonPin, INPUT_PULLUP); // Set the pin of the tactile button as an INPUT with internal pull-up resistor.
  pinMode(photocellPin, INPUT);    // Set the pin of the photocell sensor as an INPUT.

void loop() {
  lightValue = analogRead(photocellPin); // Read the analog value from the photocell sensor.

  // Check the photocell value to determine whether it's dark or light.
  if (lightValue < threshold) {
    // It's dark, turn both LEDs on.
    digitalWrite(led1Pin, HIGH); // Turn on the first LED.
    digitalWrite(led2Pin, HIGH); // Turn on the second LED.
  } else {
    // It's light, turn both LEDs off.
    digitalWrite(led1Pin, LOW);  // Turn off the first LED.
    digitalWrite(led2Pin, LOW);  // Turn off the second LED.

  buttonState = digitalRead(buttonPin); // Read the state of the tactile button.

  if (buttonState != lastButtonState) {
    if (buttonState == LOW) {
      // Button pressed, toggle LED states based on previous states.
      if (led1State == LOW && led2State == LOW) {
        led1State = HIGH;
      } else if (led1State == HIGH && led2State == LOW) {
        led2State = HIGH;
        led1State = LOW;
      } else {
        led2State = LOW;

      digitalWrite(led1Pin, led1State); // Set the state of the first LED.
      digitalWrite(led2Pin, led2State); // Set the state of the second LED.
    delay(50); // Introduce a debounce delay to prevent rapid button presses.
  lastButtonState = buttonState; // Store the current button state for comparison in the next loop iteration.



This might not have been a supper Idea, However I faced a little creativity block this week that took me a hard time to set a side

reading reflection on week 9

Physical Computing’s Greatest Hits (and misses)

What made this reading very interesting for me is that It’s all about those recurring themes in physical computing classes, and I must say, I have a soft spot for them. There’s something truly special about the way they offer a playground for creativity and innovation.

What really tickles my fancy is how Tigoe encourages us not to view these recurring themes as stale or unoriginal. Instead, he invites us to look at them as blank canvases ready for our artistic interpretation. It’s like he’s saying, “Hey, don’t shy away from these themes – they’re your chance to shine!”

Now, when we talk about themes like “Theremin-like instruments” and “Gloves,” I can’t help but get excited. I mean, who wouldn’t love the idea of creating music simply by waving their hands around? It’s not just cool; it’s a testament to the magic of human-computer interaction. And those dance pads inspired by Dance Dance Revolution? They’re pure nostalgia and joy wrapped up in a project. It’s like turning your favorite pastime into an interactive art form.

But it’s not all about play; there’s an element of challenge too. Tigoe talks about how we can add meaning to these themes by creating a physical form and context that turns simple gestures into something meaningful. That’s where the artistry comes in. It’s about infusing technology with a touch of human emotion.

And let’s not forget “LED Fetishism.” I mean, who can resist the allure of those blinking LEDs? It’s like a canvas waiting to be painted with light. The possibilities are endless, and it’s a guilty pleasure for tech enthusiasts like me. You can turn a simple LED into a work of art if you let your creativity run wild.

In the grand scheme of things, this article is a reminder that technology can be a tool for self-expression and creativity. It’s a canvas, and these recurring themes are like a familiar backdrop that sets the stage for our innovation. So, what’s not to like about that? It’s an invitation to turn everyday actions into interactive adventures, and I’m all in for that kind of excitement!

Making Interactive Art: Set the Stage, Then Shut Up and Listen

When I read this piece, it’s like a little reminder that sometimes, as artists, we tend to over-explain our creations. We put our hearts and souls into our work, and it’s only natural to want to guide others in understanding it. However, this article argues that in interactive art, there’s a beauty in leaving room for interpretation.

You see, interactive art isn’t just about creating a statement; it’s about sparking a conversation. It’s about building a stage where the audience becomes the actors. The artist sets the scene, provides the props, but then steps back and lets the audience take the spotlight.

It’s a bit like a director working with actors. You can’t tell an actor exactly how to feel or what to do to convey a particular emotion authentically. You can guide them, suggest intentions, but the true interpretation and expression come from within them. The same goes for interactive art. You design the environment, you set the stage, but you don’t need to hand-hold the audience through every step.

Instead, you offer them the basic context, suggest sequences through placement, and then let them explore. It’s like a silent invitation, a conversation between the art and the viewer. What you’ve created becomes a canvas for their emotions and thoughts.

And it’s not a one-way street. As the audience interacts with your work, they become part of this ongoing dialogue. Their reactions, their understanding, their misunderstandings – it’s all part of the artistic conversation. Some may be moved emotionally, while others might not immediately grasp the message. Some may even inspire and teach others about the work.

It’s a dynamic process, much like a performance. The audience becomes an integral part of your creation, shaping it with their responses. In a way, the art isn’t truly complete until the audience has added their unique layer to it.

Week 8- Unusual switch

  • Your concept

The unusual switch idea for my switch is an inspiration from the interaction between a football net and a ball. In this concept, the switch activates whenever the ball makes contact with the football net. To bring this idea to life, I utilized a combination of materials and components, including:

LED lights
Metal plate
Aluminum foil
Duct tape
Arduino board

By combining these elements, I was able to create a responsive and innovative switch design that engages users through the playful interaction between the ball and the net, triggering the LED lights to illuminate upon impact.

  • Embedded pics and videos

  • Reflection and ideas for future work or improvements

I’m really happy with how my Unusual circuit turned out. I like that it has a fun football theme and it was a creative project that I worked on, and I’m excited about what I’ve learned with Arduino, which is super cool. When I think about what I could do next, I’m thinking of making the circuit even more interactive and trying out other sports themes in my projects also maybe i can add a recorded sound of like someone saying GOOALL! when the ball hits the net.