int ledPin = 8;
//button stuff 2
int ledTwoPin = 10;
UCF GAIM Physical Computing
//button stuff 2
For our unconventional switch, we decided to use two cans of soda to act as our switch. We thought it would be fun to light up an LED every time you “cheered” with a buddy, making any hang out that much more fun! The alligator clips are attached to each piece of tin foil on the respective can of soda, this made the transfer more conductive for better results. When the two cans of soda touch each other, the LED lights up! Then, when the two cans of soda are pulled away from each other, the LED turns off. There is not necessarily a practical purpose for this switch, it is used mostly for entertainment value and for enhancing cheering to be more eventful and momentous.
(5v – 3v) = 0.02A * R
2v = 0.02A * R
2v / 0.02A = R
R = 100Ω
Made by:
Aidan Huggins
Andrew Parkinson
For this multi-switch assignment, I connected the Arduino board to a breadboard using the 5V and GND pins to supply power. To make the layout more organized, I bridged the power rails from one side of the breadboard to the other using jumper wires, allowing me to distribute power across both halves of the board. I placed the three buttons side by side on the breadboard. Each button is connected on one side to the positive power rail, and on the other side to a digital input pin on the Arduino to read its state. A 10kOhm resistor connects each button to ground, acting as a pull-down resistor to make the button behave as expected.
For the LEDs, I used three different colors: red, yellow, and green. Each LED is connected to a separate digital output pin on the Arduino, with the negative leg connected to ground through a 100Ohm resistor to limit current. The behavior of each LED is controlled through conditional logic in the code. The first button turns the green LED on only while the button is pressed. The second button acts as a toggle, switching the yellow LED on or off with each press. The third button controls all three LEDs by triggering a looping animation sequence..
This project aims to represent the connection between two people through physical touch. Through physically touching the two wire people together, the circuit completes itself to glow an LED. The design itself was meant to hide the underlying circuitry to emphasize the connection of the two wire armatures. The materials chosen were aluminum wire, a white LED, a half-sized breadboard, alligator clips, and a warm-toned wood. The aluminum wire allows the user to bend and manipulate the gestures while still allowing a current to pass through. The white LED was picked to allow higher visual contrast between the light and the dark aluminum, and metaphorically opens the work to more people; it establishes a connection as something without color. Logistically, the breadboard was used to hide the internals, while the alligator clips were the only consistent way to connect the non-solderable aluminum to the circuit. The warm-toned wood is meant to represent the warm connection created. The form of the two gestures also lacks detail, each with one arm to create a juxtaposition that the user can recognize. This is meant to lead the user tomake these two "arms" to touch.
This project transforms a plush Bulbasaur into a soft, interactive electronic interface using basic circuit design and conductive materials. A conductive necklace wrapped around the plush and alligator clips are attached to the necklace. This then connects Bulbasaur to wires on a breadboard-based circuit that includes a push-button, 9-volt power source, a USB power supply and an green LED. While the plush serves as an adorable tactile and conceptual interface. Whereas, the LED is activated when a physical button on the breadboard is pressed. Which allows users to manually trigger the system and observe the electrical response.
When the push-button on the breadboard is pressed, current flows from the 5-volt power source through the button, into the conductive necklace attached to Bulbasaur then through a resistor and LED before returning to ground. The resistor limits current to protect the LED from burning out. While the LED provides a visual signal that the circuit is active.
This project explores how soft materials--or adorable anime critters--and traditional electronics can be combined into playful, experimental interface. By connecting a plushie to a functioning electronic system, this highlights the expressive potential of physical computing and invites users to think of using everyday objects as interactive components.
For this project, I created an unconventional switch that lights up an LED by squeezing a lemon. I used components from my most complete starter kit, including a breadboard, jumper cables, an alligator clamp, a power source adapter set to the 5V configuration, and a multimeter to check everything was working properly.
What did I use for this? A metal lemon squeezer and an actual lemon. The objective was to demonstrate how electricity can flow through everyday items, even edible ones like fruit, and how a simple action we normally use to make lemonade or juice can be transformed into something completely different, like turning on a light.
It's a fun way to show that conductive materials are everywhere, and sometimes the most interesting circuits come from thinking outside the box.
We created a custom controller for
the fast-paced competitive platformer, SpeedRunners. The controller is
housed withing a custom 3D-printed box designed to resemble the suitcase
obstacle that shows up frequently in the game. Our conceptual model focuses on
taking this harmful game element and making it the main way for the player to
interact with the game. Instead of being an obstacle, the suitcase becomes a
tool for the player to physically interact and manipulate from the game world
to control their character. This increases immersion and creates a unique
gameplay experience based on the game’s own iconography.
The input to output mapping
involves interactions with the controller components to make game actions. A
potentiometer is used as the directional control, turning the knob is mapped
directly to the character’s left and right movement. The accelerometer is used
to make the player jump or slide. A toggle switch is used to control the
grappling hook, flipping the switch on and off activates and deactivates the
hook, very similar to how it works in the game. The ultrasonic distance sensor
is connected to boost activation and item use, putting your hand over the
sensor at different distances leads to different actions.
The controller’s design has simple
signifiers to show how to use it. The suitcase links it to the game, the knob
is the only input that fits direction, the switch is to activate and deactivate
(the grapple is the obvious one but can also see this applied to the boost),
and the motion sensor shows that there is an element of interaction with
movement in that area. The player knows these actions worked by seeing the
character in the game perform the actions and hearing the switch flipping or
the knob turning.
All these elements combine to use
the player’s familiarity to the game and common input devices such as a knob or
switch, while introducing uncommon interactions such as the distance sensor
that can make gameplay more rewarding for the player.
Question:
Do you think the use of the ultrasonic sensor for potentially fast actions like boosting and item use is effective? Can the player maintain precise control over distance while in a fast-paced match of SpeedRunners?
Contributions:
Concept- Rodrigo
C & Ralfo M
Wiring – Rodrigo C
Initial Code – Ralfo M
Updated Code + bug testing – Rodrigo C
Final Code –
Ralfo M
Description –
Rodrigo C
Prototype Enclosure – Rodrigo C
3D Print Enclosure – Ralfo M
Video and Photograph – Ralfo M
Schematics – Rodrigo C
Code:
#include <Adafruit_CircuitPlayground.h>
#include <Keyboard.h>
#include <NewPing.h>
// Map pins for Ultrasonic sensors
#define trigPin 9
#define echoPin 6
// Map pins for Potentiometer, Toggle Switch & Kill Switch
#define POT_PIN A5
#define SWITCH_PIN A6
#define MASTER_SWITCH_PIN A4
void setup()
{
CircuitPlayground.begin();
Keyboard.begin();
// Initialize Serial Monitor
Serial.begin(9600);
// Map Potentiometer
pinMode(POT_PIN, INPUT);
// Map Toggle switch & Kill switch with pull-up resistor
pinMode(SWITCH_PIN, INPUT_PULLUP);
pinMode(MASTER_SWITCH_PIN, INPUT_PULLUP);
// Map Ultrasonic sensor pins as inputs
pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);
// CPX initialization buffer
delay(1000);
}
void loop()
{
// Check if master switch is OFF
if (digitalRead(MASTER_SWITCH_PIN) == HIGH)
{
Serial.println("Controller disabled");
Keyboard.releaseAll();
delay(100);
return;
}
int potValue = analogRead(POT_PIN);
float accelY = CircuitPlayground.motionY();
int switchState = digitalRead(SWITCH_PIN);
//Debugging: Print sensor values to Serial Monitor
//Serial.print("Boost Sensor: "); Serial.println(boostDistance);
//Serial.print("Item Sensor: "); Serial.println(itemDistance);
//Serial.print("Potentiometer: "); Serial.println(potValue);
//Serial.print("Accelerometer Z: "); Serial.println(accelZ);
//Serial.print("Switch State: "); Serial.println(switchState);
Serial.println(accelY);
//Declaring variables for Ultrasonic sensor use
long duration, distance;
digitalWrite(trigPin, LOW);
delayMicroseconds(2);
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);
duration = pulseIn(echoPin, HIGH);
distance = (duration/2) / 29.1;
Serial.print(distance);
Serial.println(" cm");
//If hand detected close to sensor, use boost
if (distance <= 7)
{
Keyboard.press(0X20);
Serial.println("Boost used!");
}
else
{
Keyboard.release(0X20);
}
//If hand detected far from sensor, use item
if (distance >= 8 && distance <= 100)
{
Keyboard.press('c');
Serial.println("Item used!");
}
else
{
Keyboard.release('c');
}
delay(100);
// Potentiometer for left/right movement
if (potValue > 500)
{
Keyboard.press(KEY_LEFT_ARROW);
Keyboard.release(KEY_RIGHT_ARROW);
Serial.println("Moving Left!");
}
else if (potValue < 500)
{
Keyboard.press(KEY_RIGHT_ARROW);
Keyboard.release(KEY_LEFT_ARROW);
Serial.println("Moving Right!");
}
// CPX Accelerometer for jump & slide
if (accelY > 2.00)
{
Keyboard.press('z');
Serial.println("Jump used!");
}
else
{
Keyboard.release('z');
}
if (accelY < -2.00)
{
Keyboard.press(KEY_DOWN_ARROW);
Serial.println("Slide used!");
}
else
{
Keyboard.release(KEY_DOWN_ARROW);
}
// Toggle Switch for grappling hook
if (switchState == LOW)
{
Keyboard.press('x');
Serial.println("Grappling hook used!");
}
else
{
Keyboard.release('x');
}
// Small delay to prevent excessive key presses
//delay(50);
}
Image: