I feel that this week’s reading provides interesting insight into the disability design space, specifically in how referencing other spaces can both support and limit the development of design.

The comparison made between the design approach to glasses and hearing aids led me to consider this point. Over time, the destigmatisation and eventual popularisation of wearing glasses allowed designers to make bolder stylistic choices when producing new glasses. Comparatively, as hearing aids are slowly becoming destigmatised, the reading points out that some designers started to adopt elements from eyewear in an attempt to push the development of ‘HearWear’. While effectiveness of a design is ultimately dependent on the user to decide, I feel that this approach presents even more constraints in a context which is already presented with limitations surrounding social stigma and technical capabilities (how well the hearing aid works, how seamlessly it can be integrated into a design (discrete or otherwise)).

In response to the quote by Charles Eames stating that “design depends largely on constraints”, I do believe that too many constraints can hinder rather than progress design. In this case, I feel that the aforementioned limitations offer enough constraints for designers to experiment and develop different approaches that offer a comfortable solution for users. By adding a stipulation of following the conventions of eyewear, I feel that the designer in this case has prioritised their own creative vision over the usability and practicality of their design.

The reading offers a profound examination of the role design plays in the realm of disability, challenging the conventional perception that design for disability must focus solely on functionality. The discussion centers around the transformative potential of integrating aesthetic and cultural elements into the design of disability aids, proposing that these elements are not merely supplementary but integral to redefining these aids within broader societal contexts.

Historical examples, such as Charles and Ray Eames’s plywood leg splints, serve as a foundation for arguing that design constraints related to disability can catalyze broader innovations in design practice. The Eames’s ability to transform a functional object like a leg splint into a design that influenced their later iconic furniture pieces illustrates how solutions born out of necessity can transcend their origins to impact broader design disciplines. This notion is further reinforced through the transformation of eyewear from a stigmatized medical necessity into a fashionable accessory, which underscores the potential for disability aids to evolve beyond their functional inception towards cultural significance.

However, this integration of aesthetics raises questions about the balance between form and function, reflecting a potential bias towards design that may overlook practical user needs like accessibility and affordability. While the reading persuasively invites a rethinking of disability aids as elements of personal identity and expression, it also prompts critical reflections on ensuring these designs remain accessible and practical. The challenge lies in achieving a harmonious integration where design innovations in the disability sector do not compromise on functionality, ensuring that these aids are not only culturally resonant but also remain true to their primary purpose of serving the needs of the disabled community.

Inspiration and Concept

Ever since I’ve come to Abu Dhabi, my passion for jet-skiing and boats has been growing and growing inside me. At the same time, I wanted to do something unique, something that nobody has ever done before. That is why for this final project I decided to make a boat. 

I want the boat to be controlled by the users hand, and with gestures like: if you want to go left, you slide your arm to the left, if you want to go right, you slide your arm to the right. Same thing goes for the speed. If you want to go faster, you put your hand closer to the sensor (kind of like a pedal).

Implementation

The implementation phase can be very easily explained. For the gestures of the user, I would like to use this sensor that is available in our booking website:

 

I have also found a 3d model for the boat and matched the size so that It can fit the Arduino, the Breadboard and the Batteries. The plan is to attach a fan to a DC Motor, and attach the DC Motor to a Servo, which would be used to set the directions. As the user moves his hands, the servo will adjust the angle accordingly and the dc motor will adjust the power too. The communication will be done through a wireless receiver which would be provided by PI.

I plan to use p5.js only as a “dashboard” highlighting the way the boat is headed (straight, right, left) and also the speed. It would be interesting if I could animate the boat so that it shows some fun animation If we are speeding up or turning too sharply.

Concept

For my final project, I am yet again choosing to go with a butterfly theme. This time, however, I plan to give it a little life – in the real physical sense. With the ability of bringing hardware components together, and controlling them programmatically, we can simulate many things. I will attempt to do just that and bring a little life to a small butterfly.

My final project will essentially be a physical, mini-interface with a butterfly that reacts to human touch. The interface will display a butterfly atop a flower, undisturbed and resting peacefully. Once touched, its wings will flutter, awakening a swarm of butterflies that begins to flap away from beneath. The interface itself will be a physical surface on a table, with the animation, designed and implemented in p5.js, projected onto it. The interface will have a physical butterfly prototype (made from paper and laminated, perhaps) protruding in the middle. Once a sensor (a capacitive touch sensor) that is connected to it senses a signal, its wings will be activated and so will the butterflies’ animation in the backdrop. Its wings will be attached to two servo motors that will move once a signal is received from p5.

Materials and Hardware

1. Arduino Uno and breadboard
2. Capacitive touch sensor
3. Two servo motors
4. A general-purpose tripod
5. A projector

p5.js

The p5.js sketch is responsible for creating and controlling the animation. For the creation of butterfly objects, I tried experimenting with generative art, but it proved to be quite challenging as I needed to simulate the smooth motion of flapping wings. I, hence, will be using standard images (spritesheets) to display the graphics. The p5.js sketch will consistently read the messages transmitted from the Arduino program, waiting for a touch signal to activate the motion of the butterfly wings and the subsequent animation. Once the animation begins, it will send messages to the Arduino program, communicating that the animation is still underway. These messages are going to be used to keep the servo motors, controlling the wings, in motion. Once the animation stops, as indicated by all the smaller butterflies that escaped from beneath the central butterfly leaving the screen display, the sketch will send a terminating message to the Arduino, which will be used to bring the motion of the servos to a halt.

In order to ensure a seamless mapping experience between the sketch and the physical surface, I will be using p5.mapper. This library allows you to calibrate your sketches dynamically in order to match the dimensions of your sketch with that of a surface, once projected.

Arduino

The Arduino program will have a touch sensor as an input and servo motors as output. The touch sensor sends a signal to p5 indicating a touch is detected and will receive messages used to control the duration of the motor-controlled wing flaps.

Progress

p5

So far, I have the major parts of my sketch (the animation, serial communication, and projection mapping) completed for the most part. I want to work on the aesthetics of it a little more next and will have to modify the serial communication implementation to synchronize the movement of the motors.

https://editor.p5js.org/sarah-altowaity1/sketches/5eZkJXShI

Arduino

The main circuitry is wired up to connect the touch sensor and the motors. The program sends the sensor signal over to p5 for detection of touch. I, additionally, implemented the wing flap motion with the motors. However, I still need to work on the synchronization between the animation and the servo movements. I also need to figure out a way to conveniently and securely place the wings on the motor flaps and stabilize the components.

Sketch mapped onto a surface

Next Steps

The main next step is putting it all together and completing the technical aspects of synchronizing the animation with the physical components. I also need to work on designing a neat interface with stable components as I would like to reduce the overhead of setting up (and the possibility of things falling apart or out-of-sync) as much as possible.

Bomb Defusal Game: Defuse Dash

Concept

The bomb defusal game is an interactive physical and digital game where players must complete a series of tasks using a combination of hardware components and a computer interface to “defuse” an Arduino bomb within a set time limit. Each task involves different components such as buttons, a potentiometer, and an ultrasonic sensor, providing a variety of challenges that test the player’s reaction speed, precision, and problem-solving skills.

Responsibilities

• P5.js
  • Visual Display: Renders the game interface, including task instructions, status updates, and timers.
  • User Interaction: Processes and displays inputs received from the Arduino, allowing players to see the results of their actions in real time.
  • Game Feedback: Provides immediate visual feedback based on player actions, such as changing colors or displaying messages to indicate success or failure.
• Arduino
  • Input Reading: Collects and processes inputs from physical game controls (buttons, potentiometer, ultrasonic sensor).
  • Logic Handling: Executes the core game mechanics based on player interactions and sends the status to P5.js.
  • Output Control: Manages physical outputs like sounds (buzzer or servo) to enhance gameplay interaction.

Game Mechanics

Task-Based Gameplay: Players face multiple tasks that they must complete to defuse the bomb. Each task uses different components:

• Button Presses: Used for tasks like code entry, where players must press the correct sequence of buttons.
• Potentiometer Adjustments: This might involve setting a dial to match a specific level displayed on the P5.js interface.
• Ultrasonic Sensor: Requires players to move an object to the correct distance from the sensor as shown by the computer interface.
• LEDs: Used to provide visual feedback on task status (e.g., success, warning, error). The Arduino controls these LEDs based on the game state and player inputs.
• Piezo Speaker: Can emit different tones or alerts based on game events like task success, failure, or warnings.

Time Limit: The game is timed, adding pressure and requiring quick thinking and fast responses. Failing to complete tasks within the time limit results in a game-over scenario.

Current Progress

• Circuit Setup: Configured a basic circuit with 2 buttons, 1 potentiometer, and 1 ultrasonic sensor connected to an Arduino Uno.
• Arduino Programming: Developed code to read inputs from the hardware components and send this data to the P5.js application via serial communication.
• P5.js Programming: Set up a P5.js sketch to receive data from Arduino and visually display game elements such as task instructions, player inputs, and a timer.

The reading “Design Meets Disability” explores the relationship between beautiful design and practical usability while arguing for a change in perceptions of the design of items intended for people with disabilities.

The growth of eyeglasses from a stigmatized medical device to a stylish accessory demonstrates how design has the ability to alter views. In the past, glasses were frequently associated with social shame and were only considered useful instruments for correcting vision. But by adding fashion components to its designs, eyewear has evolved into an item that is for use and visual appeal.

Aimee Mullins, a model and athlete, has demonstrated how creatively she uses prosthetic limbs to emphasize the need for cross-disciplinary collaboration between fashion designers and disability product designers. Her prostheses, which are both artistically beautiful and practical, are a prime example of how incorporating fashion into disability design can defy stereotypes and turn medical devices into fashion statements.

Is it possible for the aesthetics of assistive devices to impact how society views and treats people with disabilities? If yes, how can designers use this authority to promote greater acceptance and inclusion?

So far for my final project I have narrowed down all the ideas I have and created most of the graphics needed, I also started getting into the code and researching tutorials I might need.

I have split my game into 3 stages, each requiring a different sensor: a Potentiometer, a Joystick, and a button. Through these 3 sensors, I will go through the 3 cooking steps to create the final dish. I haven’t gone to much into audio yet but I think I have a general idea.

Below you’ll find the sketch so far (still not much going on) and some of the art I’ve created for now.

 

Initial connection and wiring from the schematic:

Exercise 1:

This was probably the easiest exercise, we just had to edit the code that was in the Week 12 Lecture Notes.

P5.js Code:

let potentiometer = 0;

function setup() {
  createCanvas(640, 480);
  textSize(18);
}

function draw() {
  background(255);
 
  if (!serialActive) {
    text("Press Space Bar to select Serial Port", 20, 30);
  } else {
    text("Connected", 20, 30);
    text('Potentiometer = ' + potentiometer, 20, 70);
  }

 
  let ellipseX = map(potentiometer, 0, 1023, 0, width);
  fill(0);
  ellipse(ellipseX, height / 2, 50, 50);

function keyPressed() {
  if (key === ' ') {
    setUpSerial();
  }
}

function readSerial(data) {
  if (data != null) {
    let trimmedData = trim(data);
    if (!isNaN(trimmedData)) {
      potentiometer = int(trimmedData);
    }
  }
}

Arduino Code:

void setup() {
  Serial.begin(9600);

  pinMode(LED_BUILTIN, OUTPUT);
  digitalWrite(LED_BUILTIN, HIGH);
  delay(200);
  digitalWrite(LED_BUILTIN, LOW);
}

void loop() {
  int sensorValue = analogRead(A1);

  Serial.println(sensorValue);

  delay(10);
}