Finalized concept:
My finalized concept is still Fruit Ninja XR, but the only change is that I am currently using an accelerometer instead of a flex sensor, The program uses the camera to get the user’s hands x position using the ml5 hand pose model, and then while rotating the Arduino the y axis changes.
The Arduino will be moved in a knife motion and will send the y value of the accelerometer to change the y value of the cutter in the p5 sketch.
The p5 will not send any data to the Arduino. The p5 sketch captures the camera input from the device and detects the user’s hand. Also, the p5 sketch generates fruits and bombs from the bottom of the screen and throws them in a projectile motion. After the user slices through a fruit a line with an angle of slicing appears, the fruit gets sliced into two halves, and then the score increases by one. If the user slices a bomb, the bomb explodes, he loses a life, and the screen goes white for a couple of seconds.
The reading reminds me about the question of whether we should make disability look normal or to make it visually attractive. There are different ways of how equipment for disability can be presented. One of them is making it become a part of fashion. It is similar to the example of eyeglasses. Eyeglasses are a tool for eye problems. However, it has become a fashion tool, an accessory for clothes matching. It seems the first thing they will see is the glasses because they are dangling on our face.
However, in the similar case of the hearing aids, its presence seems to be more and more invisible. Its design has become so small that if we do not look for it, we may miss it. Controversially, the earbuds, which are also used for hearing, are more and more widely used. If something such as the earbuds has become so common, why is there a need to hide away the hearing aids?
Comparing the two different examples, it seems that there are some unknowing gaps between design for everyone and design for disabilities. I think it is because of the actual needs of the majority of the crowd. For example, the glasses can be worn without the wearer actually having any visual problem. On the other hand, hearing aids can only be used for those who need them. There are also differences in accessibility where glasses are widely sold and the hearing aids are produced by specific companies.
Reading “Design Meets Disability” felt like a light bulb turning on in my head. I’d never really thought about disability as something created by society, you know? It made me realize how much design impacts people’s lives, either by opening doors or putting up walls.
The part about universal design really stuck with me. It’s like, why wouldn’t we want to make things that everyone can use and enjoy? It just makes sense! It’s like that curb cut example – it helps so many people, not just those in wheelchairs. It shows how good design can be helpful and just plain smart.
The book also reminded me of the saying, “Nothing About Us Without Us,” which is all about giving disabled people a voice. It made me think about how important it is for designers to actually listen to the people they’re designing for, especially when it comes to accessibility. Their experiences are what matters most, and they can help create designs that truly work for everyone.
This book really got me thinking. How can we get more designers on board with inclusive design? How can we work together to make sure accessibility isn’t just an afterthought? These are big questions, but I think finding answers is super important for creating a world where everyone feels welcome and valued.
I found “Designer Meets Disability” to be really meaningful. Not only was it a thought-provoking read, but it also made me consider my own design methods and prejudices. I was forced to reconsider what good design actually entails after reading this book, particularly in light of accessibility.
I remember a project I worked on where I had to use p5.js to create an interactive experience. At first, all I concentrated on was making things look good and work well enough for the average user. But reading this book made me see how important it is to take into account the people who might interact with my work in a different way. This realisation completely changed the way I approached design.
Especially inspirational was the notion that disability may spur innovation rather than hinder it. It has forced me to take a more expansive view, realising that include accessibility from the outset benefits everyone by enhancing both the design process and the final product, rather than just being about ethics or compliance.
I’m more dedicated than ever to making sure that my designs are not just aesthetically pleasing and useful, but also widely accessible as I work on my interactive media projects. Regardless of a person’s ability, I aim to create experiences that they can all enjoy and profit from.
For this assignment, it displays an ellipse whose horizontal position is controlled by a potentiometer connected to an Arduino board. When the space bar is pressed, it establishes a serial connection. The Arduino continuously reads the potentiometer value and sends it to the P5.js sketch via serial communication, allowing real-time adjustment of the ellipse’s position.
P5js code:
let ellipseHorizental;
function setup() {
createCanvas(640, 480);
textSize(18);
ellipseHorizental = width/2;
}
function draw() {
background(220);
// Draw ellipse with width based on potentiometer value
fill("green");
ellipse(ellipseHorizental, height / 2, 100, 150);
if (!serialActive) {
text("Press Space Bar to select Serial Port", 20, 30);
} else {
text("Connected", 20, 30);
// Print the current potentiometer value
text('Potentiometer Value = ' + str(ellipseHorizental), 20, 50);
}
}
function keyPressed() {
if (key == " ") {
setUpSerial();
}
}
function readSerial(data) {
if (data != null) {
// convert the string to a number using int()
let fromArduino = split(trim(data), ",");
// Map the potentiometer value to the ellipse width
ellipseHorizental = map(int(fromArduino[0]), 0, 1023, 0, 640);
}
}
Arduino code:
const int potPin = A0; // Analog pin connected to the potentiometer
void setup() {
Serial.begin(9600);
}
void loop() {
int potValue = analogRead(potPin); // Read the value from the potentiometer
// Send the potentiometer value to p5.js
Serial.println(potValue);
}
Video:
Assignment 2:
For assignment 2 it establishes communication between a P5.js sketch and an Arduino board for controlling LED brightness. The P5.js sketch allows users to adjust brightness by dragging the mouse horizontally, with instructions displayed when the serial connection is active. The Arduino board continuously waits for serial data from the P5.js sketch, adjusting the LED brightness accordingly. During setup, a handshake process is initiated, blinking the built-in LED while waiting for serial data.
P5js code:
let brightness = 0; //variable for brightness control
function setup()
{
createCanvas(400, 400); //create canvas
}
function textDisplay() //display text in the starting
{
text("PRESS SPACE TO START SERIAL PORT", width/2 - 109, height/2 - 5);
}
function draw()
{
background(220); //grey background
if (serialActive) //if serial is active
{
text("connected", width/2 - 27, height/2 - 5); //tell the user that it is connected
text("Drag the mouse horizontally to change brighthess", width/2 - 130, height/2 + 15); //give instructions on how to control brightness
}
else
{
textDisplay(); //display instructions on how to start serial is not active
}
if (mouseX >= 0 && mouseX<=10){
brightness = 0;
}
else if (mouseX >= 3 && mouseX<=width/5){
brightness = 51;
}
else if(mouseX >= width/5 && mouseX<=2*width/5){
brightness = 102;
}
else if(mouseX >= 2*width/5 && mouseX<=3*width/5){
brightness = 153;
}
else if(mouseX >= 3*width/5 && mouseX<=4*width/5){
brightness = 204;
}
else if (mouseX>=4*width/5){
brightness = 255;
}
else{
brightness = 0;
}
}
function keyPressed() //built in function
{
if (key == " ") //if space is pressed then
{
setUpSerial(); //setup the serial
}
}
//callback function
function readSerial(data)
{
let sendToArduino = brightness + "\n"; //add the next line to dimness counter
writeSerial(sendToArduino); //write serial and send to arduino
}
Arduino code:
int LED = 5; // Digital pin connected to the LED
void setup() {
Serial.begin(9600);
pinMode(LED_BUILTIN, OUTPUT);
pinMode(LED, OUTPUT);
// start the handshake
while (Serial.available() <= 0) {
digitalWrite(LED_BUILTIN, HIGH); // on/blink while waiting for serial data
Serial.println("0"); // send a starting message
delay(300); // wait 1/3 second
digitalWrite(LED_BUILTIN, LOW);
delay(50);
}
}
void loop() {
// wait for data from p5 before doing something
while (Serial.available()) {
digitalWrite(LED_BUILTIN, HIGH); // led on while receiving data
int brightnessValue = Serial.parseInt();
if (Serial.read() == '\n') {
delay(5);
Serial.println(brightnessValue);
}
analogWrite(LED, brightnessValue);
digitalWrite(LED_BUILTIN, LOW);
}
}
Video:
Assignment 3:
For this assignment, we tried to establish communication between a P5.js sketch and an Arduino board (bi-directional). The P5.js sketch simulates a ball’s motion affected by wind and gravity, with its behavior controlled by sensor data received from the Arduino. The Arduino reads data from an ultrasonic sensor to determine distance, sending LED control signals back to the P5.js sketch based on the received distance data, influencing wind direction and LED turning on.
P5js code:
//declare variables
let velocity;
let gravity;
let position;
let acceleration;
let wind;
let drag = 0.99;
let mass = 50;
let LEDvalue = 1401;
let goRight = 0;
let goLeft = 0;
let first
function setup() {
createCanvas(1000, 360); //create canvas
noFill();
position = createVector(width/2, 0);
velocity = createVector(0,0);
acceleration = createVector(0,0);
gravity = createVector(0, 0.5*mass);
wind = createVector(0,0);
}
function textDisplay()
{
text("PRESS SPACE TO START SERIAL PORT", width/2 - 109, height/2 - 5); //display the appropriate text in the start
}
function draw() {
background(255);
if (serialActive) //if the serial is active
{
applyForce(wind);
applyForce(gravity);
velocity.add(acceleration);
velocity.mult(drag);
position.add(velocity);
acceleration.mult(0);
ellipse(position.x,position.y,mass,mass);
if (position.y > height-mass/2) //if the ball touches the bottom
{
velocity.y *= -0.9; // A little dampening when hitting the bottom
position.y = height-mass/2;
LEDvalue = 1401; //take LED value to be 1401 because we dont want the value (1) to be lurking in the serial and then affecting the wind values
}
else
{
LEDvalue = 1400; //when the LED is off
}
}
else
{
fill(0);
textDisplay();
}
}
function applyForce(force){
// Newton's 2nd law: F = M * A
// or A = F / M
let f = p5.Vector.div(force, mass);
acceleration.add(f);
}
function keyPressed(){
if (key==' '){ //if space is pressed, then serial is set up
setUpSerial();
}
if (keyCode == DOWN_ARROW) //if down arrow is pressed
{
//mass etc is changed
mass=random(15,80);
position.y=-mass;
velocity.mult(0);
}
}
function readSerial(data) //call back function
{
let sendToArduino = LEDvalue + "\n"; //sends value of LED to Arduino with \n added
writeSerial(sendToArduino); //write to Arduino
if (data != null) //if the data is not null and something is received
{
console.log(data);
if (data > 1450) //if the distance is greater than 1450, then
{
wind.x = 1; //the ball/wind goes right
}
else if (data < 1350) //if the distance is less than 1350
{
wind.x = -1; //the ball/wind goes left
}
}
}
Arduino code:
//declare variables
const int LED_PIN = 4;
int LEDvalue = 0; //will contain whether or not the LED should be on or off
int distance = 0; //will contain the distance by ultrasonic sensor
const int pingPin = 2; //Trigger Pin of Ultrasonic Sensor
const int echoPin = 3; //Echo Pin of Ultrasonic Sensor
void setup()
{
Serial.begin(9600); // Start serial communication at 9600 baud
pinMode(LED_PIN, OUTPUT); //pin mode is output
//Set the ultrasonic sensor pins as output and input respectively
pinMode(pingPin, OUTPUT);
pinMode(echoPin, INPUT);
while (Serial.available() <= 0)
{
Serial.println(1400); //connection establishment. 1400 so that the wind values do not change
}
}
void loop()
{
//wait for p5js
while (Serial.available())
{
sensorReading(); //reads data from the sensor
LEDvalue = Serial.parseInt(); //parsing from the serial written data from p5js
if (LEDvalue == 1400) //if the LED value is 1400
{
digitalWrite(LED_PIN, LOW); //then turn off the LED
}
else if (LEDvalue == 1401) //if the LED value is 1401
{
digitalWrite(LED_PIN, HIGH); //then turn on the LED
}
}
}
//Function to read the ultrasonic sensor and measure distance
void sensorReading()
{
//Send a short low pulse
digitalWrite(pingPin, LOW);
delay(2); //delay to avoid complications
digitalWrite(pingPin, HIGH); //sends a high pulse for 10 microseconds
delay(10);
digitalWrite(pingPin, LOW); //turn off the ping pin
distance = pulseIn(echoPin, HIGH); //Measure the duration of the ultrasonic pulse and calculate the distance
Serial.println(distance); //print the serial from distance
}
The reading from “Design Meets Disability” suggests a profound paradigm shift in the approach to design, particularly for products meant to be accessible for all, including those with disabilities. This shift moves away from a focus on mere functionality and discretion toward a more holistic view that embraces aesthetic appeal, personal identity, and cultural relevance.
The text draws attention to the meticulous process behind achieving the apparent simplicity of designs like the iPod, which balances minimalism with functionality and accessibility. It emphasizes the idea that while simplicity in design is often celebrated, the complexity involved in achieving it is substantial and not necessarily apparent to the end-user.
Further discussed is the idea of “spimes,” a term coined by Bruce Sterling to describe objects that are more than their physical form; they are information-rich, context-aware, and sustainable. This represents a vision of the future where products are integrated into our lives in a way that is both meaningful and mindful of the larger ecological and informational ecosystems they inhabit.
Moreover, the reading posits that designs should not be solely driven by the technological capability or the imperative of universality but should consider the nuanced needs and preferences of individual users, which includes emotional and psychological responses. It illustrates that designing for disability isn’t just about providing a function; it’s about creating an experience and empowering the user.
the challenge presented to designers: to forge a path that neither patronizes nor alienates but instead enriches the user’s life. It calls for a commitment to design that is not only inclusive in its utility but also in its beauty and its ability to resonate with users on a personal level. The aim is to push the envelope of what is possible, creating products that are not just usable by everyone but also desirable by everyone, thus fostering a more inclusive and empathetic society.
I initially gave the idea to professor to make this reading optional since we have a lot on our plate with the final being due, but since its extra credit, it automatically became crucial for me to complete 🙂
So while reading “Design Meets Disability” by Graham Pullin, it has profoundly shifted my view on the design of assistive devices. Pullin advocates for merging functionality with aesthetic appeal, an approach that resonates deeply with current trends in consumer technology. For example, the transformation of eyeglasses from functional items to fashion statements illustrates the potential for assistive devices to follow a similar trajectory.
However, the reality in the market shows a lag in adopting this inclusive design philosophy. Many devices, especially those for less visible disabilities, remain primarily functional, highlighting a gap between Pullin’s ideal and the industry’s current practices. This discrepancy might be due to cost constraints and a lack of awareness among designers about how to integrate aesthetics without compromising functionality.
Reflecting on this, I am more aware of the biases that might exist in the design community and society’s perception of disability. Pullin’s optimism is inspiring, yet it also brings to light the practical challenges of such a vision. It raises crucial questions about balancing cost and style and how the industry can be motivated to embrace this more holistic approach to design.
Reflecting on “Design Meets Disability,” the book pushes the boundaries of traditional views on assistive device design by advocating for a blend of functionality and aesthetic appeal. This approach resonates strongly with the current trends in consumer technology, where design and personal expression play pivotal roles. For instance, eyewear, originally a purely functional item for vision correction, has evolved into a fashion statement, highlighting the argument that assistive devices can similarly be fashion-forward and not just functional. However, while Pullin champions a more inclusive design philosophy, evidence from the current market for assistive devices shows a lag in the widespread adoption of this philosophy. Many products, particularly for less visible disabilities, remain starkly functional, suggesting a discrepancy between Pullin’s ideal and the industry’s execution. This gap may stem from various factors, including cost constraints and limited awareness among designers about the possibilities for aesthetic integration without compromising functionality.
The reading subtly nudges one to consider potential biases in how society and designers view disability and assistive technologies. Pullin seems optimistic about the convergence of design and disability, which might seem biased to those who see significant structural and societal barriers still in place. This optimism does not fully address the economic and practical challenges of redesigning assistive devices as fashionable items, which could be perceived as an oversight or a bias towards a more idealistic outlook. The reading has shifted my perspective, making me more aware of the need for a holistic approach to design—one that considers both function and form. It raises questions about the feasibility of such integration: How can designers balance the cost implications with the desire for style? How can the industry be incentivized to adopt this approach? These questions underline the complexities of implementing Pullin’s vision in real-world settings, suggesting the need for a broader dialogue among designers, manufacturers, and users within the disability community.
In “Design Meets Disability,” Graham Pullin talks about how functionality meets aesthetics in the realm of assistive technologies. It was interesting how Pullin challenges the traditional views that often limit the design of assistive devices to practical purposes.
The call for a “design revolution” in the disability sector was very intriguing as Pullin illustrates this with the transformation of eyeglasses from simple visual aids to fashion accessories, showing us how societal perceptions and user demands can dramatically shift design priorities. This transformation, he argues, should serve as a blueprint for other assistive devices.
Pullin delves into the social implications of design choices, suggesting that the aesthetic neglect often found in the design of disability aids can reinforce feelings of stigmatization. By integrating design principles from mainstream fashion and technology, he suggests that these devices can instead promote a sense of pride and personal identity.
What I liked most was how realistic Pullin is about the challenges, he acknowledges the complexities of designing for such a diverse range of needs and the potential higher costs associated with the design concepts.
