Tasbeeh

Context & Sifnificance

In our midterm project, the glove device for counting prayers directly reflects the insights gained from my previous work on the bracelet and hug-sleeves. These projects influenced our approach by highlighting the importance of wearability and utility, which has inspired us to create another wearable device—one that is not only comfortable but also useful in solving a real-world problem. Through the bracelet, I learned that interaction should be intuitive and unobtrusive, allowing users to engage seamlessly with technology in a way that feels natural and effortless. This understanding shaped my definition of interaction as something that integrates seamlessly into daily life, providing benefits without creating distractions or complications.

Glove provides a quiet, focused way for users to count prayers, exemplifies this definition. Its simple design—allowing users to press fingers for counts, see updates on a screen, and receive audible feedback every five counts—offers a streamlined experience. The fact that it beeps longer when held for three seconds adds functionality that feels intentional rather than disruptive. This device stands out because it fills a unique gap: a wearable prayer counter that doesn’t exist in this form on the market, making it a significant contribution for users with religious counting needs. 

By focusing on comfort and ease of use, the glove provides religious individuals a more immersive way to track prayers without the distraction of traditional beads, offering both convenience and innovation for its intended audience.

Conception and Design

The sketch

We chose cotton fabric for the glove, prioritizing comfort, breathability, and flexibility. Cotton allows for natural movement of the fingers without restricting them, which is essential for users who will be pressing fingers frequently. Cotton is also lightweight and soft, making it suitable for extended wear, which aligns well with the user experience you envisioned—something comfortable enough for daily use. Another option was synthetic material, which might offer more durability or moisture resistance. However, synthetics can often feel less breathable and less comfortable over time, so cotton was a better choice for a wearable intended for continuous use.

Since the glove displays counts, the inclusion of a screen was carefully considered. A small, unobtrusive screen was selected to avoid overwhelming or distracting the user, and it’s positioned in a way that makes it easy to view without needing to remove the glove. 

The decision to include a beep every five counts and a longer beep when the user holds the sensor for three seconds ensures that users have feedback. This interaction design choice respects the spiritual focus of the task by providing subtle feedback that doesn’t require constant visual engagement, making the glove even more user-friendly.

Using copper tapes on the fingers allows for an intuitive and natural way of counting, simply by pressing the fingers together. This decision was informed by the idea that users should be able to perform the task in a way that feels as close as possible to using traditional prayer beads, so users don’t have to adopt an entirely new gesture or method. Alternative methods, like gesture recognition or touch screens, might have added complexity, taking away from the simplicity and ease of use that was prioritized.

Each of these design decisions contributes to a cohesive user experience that feels familiar yet innovative, grounded in an understanding of the users' needs for a comfortable, easy-to-use device that enhances rather than distracts from their practices.

Fabrication and Production

1-step: Conceptualization and Design

Initially, we brainstormed wearable designs that would be comfortable and user-friendly, inspired by our previous group project’s wearable bracelet and hug-sleeves. We quickly narrowed our ideas down to a glove due to its natural fit with counting gestures. 

2-step: Electronics and Circuit Design

The glove required a flexible circuit that would still be reliable. We used copper tape on the fingers to serve as touchpoints, connected to an Arduino breadboard via  strand wires. My partner soldered the strand wires, so the wires of each finger could be connected together. Each time the user pressed a finger, a connection would be made, sending a signal to the Arduino, which kept the count. I was responsible for soldering the wires to the copper tapes and ensuring the wires from the copper tape were secured to the Arduino. We chose copper tape for its conductivity and flexibility, but it presented challenges when adhering to fabric, leading to frequent checks and adjustments. My partner mostly was responsible for the code, while I was responsible for the design and assembling.

3-step: Coding and Functional Testing

The code was essential in handling the count logic, screen display, and buzzer timing. Each press on the copper tape incremented the counter, and every five counts, the buzzer beeped to notify the user. We wrote and tested parts of the code, specifically the section that triggered different sounds based on count intervals and screen updates. Testing the functionality helped us fine-tune the code, ensuring that it responded smoothly to each press without delay. We encountered several problems during the process of writing the code: the buzzer beeped only once and did not beep the subsequent 10,15,20,25, also the sound of the beep was not pleasant to listen, it took 3 times to adjust the frequency of the sound. Also, the screen was not showing the numbers as in Serial Monitor, after adjusting the code we could make it to show each number one at a time.

4-step: User Testing and Adaptations

In our user testing session, participants were invited to try on the glove and provide feedback. Most users appreciated the glove’s comfort and functionality; however, they noted discomfort due to the positioning of wires, which sometimes tangled and disrupted the counting experience. Based on this feedback, we made the adjustment of taping the wires together on one side of the glove, reducing bulk and making the device more comfortable. 

5-step: Final Adjustments and Justification

Following user testing, we assessed each component’s placement and made slight adjustments to the copper tape positioning to improve accuracy in counting. The buzzer and screen, housed on the breadboard, were checked for stability, as these were essential in providing real-time feedback to users. Each production choice, from using copper tape to selecting a cotton glove, was made with the goal of balancing functionality and comfort. Ultimately, we created a product that aligned with our project goals, providing a reliable and comfortable tool for counting prayers.

- Material: The cotton glove provided flexibility and comfort, meeting the essential requirement of prolonged wearability.

- Copper Tape: This was crucial for effective signal transmission while allowing for natural finger movement.

- Wire Organization: Taping the  strand wires to one side based on user feedback was effective in improving comfort and usability.

Code: 

#include <Wire.h>

#include <Adafruit_GFX.h>

#include <Adafruit_SSD1306.h>

#define SCREEN_WIDTH 128  

#define SCREEN_HEIGHT 64  

// Declaration for an SSD1306 display connected to I2C (SDA, SCL pins)

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);

long startTime = -1; // Stores the time the button was last pressed

int n = 1; // Used to control when the buzzer beeps (at every five counts)

int Button = 2; // Button is connected to pin 2

int prevVal; // Stores the previous state of the button

int count = 0; // Counter variable

#define buzzer 8 // Buzzer connected to pin 8

bool buzzState = false; // State of the buzzer (whether it's currently beeping)

void setup() {

  Serial.begin(9600); // Start serial communication

  pinMode(buzzer, OUTPUT); // Set buzzer pin as output

  pinMode(Button, INPUT); // Set button pin as input

  // Initialize OLED display with I2C address 0x3C

  if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {  

    Serial.println(F("SSD1306 allocation failed")); // Error message if display fails

    for (;;);  

  }

  delay(2000); // Wait for the display to initialize

  display.clearDisplay(); // Clear the display

  display.setTextSize(2); // Set text size for count display

  display.setTextColor(WHITE); // Set text color to white

  // Display static text "Count:" on screen

  display.setCursor(0, 10); // Set cursor position

  display.println("Count:");  

  display.display();  

}

void loop() {

  int val = digitalRead(Button); // Read button state

  // Detect a button press (LOW to HIGH transition)

  if (prevVal == LOW && val == HIGH) {

    startTime = millis(); // Store the time of the press

    count++; // Increment count

    Serial.print("count:"); // Display count in Serial Monitor

    Serial.println(count);

    // Update count on the OLED screen

    display.fillRect(0, 30, SCREEN_WIDTH, 16, BLACK); // Clear previous count display

    display.setCursor(0, 30); // Position for new count

    display.println(count); // Display updated count

    display.display();

  }

  // Check if count has reached a multiple of 5 and beep if it has

  if (count == (n * 5) && !buzzState) {

    tone(buzzer, 500, 100); // Beep the buzzer

    buzzState = true; // Set buzzer state to active

    n++; // Increase multiple counter

  } else {

    noTone(buzzer); // Stop the buzzer

    buzzState = false; // Reset buzzer state

  }

  // If button is held for more than 3 seconds, reset the count

  if (prevVal == LOW && val == HIGH) {

    startTime = millis(); // Update start time on button press

  } else if (millis() - startTime > 3000 && prevVal == HIGH && val == HIGH) {

    tone(buzzer, 1000, 100); // Beep to indicate reset

    count = 0; // Reset count to zero

    n = 1; // Reset buzzer control variable

    Serial.println("restart"); // Indicate restart in Serial Monitor

    startTime = -1; // Reset start time

    // Clear and update the display with the reset count

    display.fillRect(0, 30, SCREEN_WIDTH, 16, BLACK);

    display.setCursor(0, 30);

    display.println(count);

    display.display();

  }

  prevVal = val; // Update the previous button state

  delay(50); // Short delay for button debouncing

}

User Testing

Conclusions

The primary goal of our project was to create a wearable device that would enable users to count prayers in a comfortable, intuitive, and unobtrusive way. By focusing on ease of use and a familiar gesture (pressing fingers together), we aimed to enhance the prayer experience, making it more focused and less distracted by the mechanics of counting. Our glove design aimed to seamlessly integrate into users' daily rituals, aligning with our broader definition of interaction as a fluid, natural engagement with technology that provides benefit without adding complexity.

The final product largely achieved this goal, meeting our definition of interaction by providing a comfortable, easily wearable device that users could interact with in a way that felt almost effortless. The glove’s design allowed for natural gestures, and feedback mechanisms (both visual and auditory) were intuitive, keeping the focus on prayer rather than on the device itself. This alignment validated our understanding of interaction as something that feels part of the natural flow of a task rather than a disruption.

However, there were some limitations. The wiring, though minimized through adjustments, still detracted slightly from the glove’s seamlessness, reminding users that they were engaging with a piece of technology. This aspect didn’t fully align with our ideal of a completely integrated experience, as the wires could still occasionally feel cumbersome.

During the user testing session, our audience responded positively to the concept and comfort of the glove, with many remarking on the practicality of the cotton material and the intuitiveness of the gesture-based counting. The minor discomfort caused by the wires was an issue, but our solution to tape them to one side was effective in improving usability. Users ultimately interacted with the glove as we had hoped—by focusing on prayer rather than the mechanics of counting.

With more time, we would explore alternative solutions to manage or conceal the wiring more effectively. For example, embedding conductive fabric or flexible PCBs directly into the glove could eliminate the need for loose wires, enhancing comfort and integration. We might also test additional sensory feedback options, like a vibration response instead of a beep, to create an even subtler notification system.

Through setbacks like wiring discomfort and copper tape adherence issues, we learned the importance of iterative user testing and adaptability in wearable design. Each challenge forced us to consider how users would interact with every component, highlighting the value of flexibility and user-centered modifications. From our successes, we take away the insight that interaction design is most effective when grounded in real user needs and comfort, reinforcing the need for empathetic design choices in wearable technology.

In conclusion, our prayer-counting glove successfully combined functionality with comfort, creating a unique and user-centered tool for spiritual practice. This project taught us valuable lessons in balancing form, function, and user experience—learnings that will undoubtedly shape our future designs.

Disassembly

Appendix

#include <Wire.h>

#include <Adafruit_GFX.h>

#include <Adafruit_SSD1306.h>

#define SCREEN_WIDTH 128  

#define SCREEN_HEIGHT 64  

// Declaration for an SSD1306 display connected to I2C (SDA, SCL pins)

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);

// This was adapted from the tutorial found here:

Guide for I2C OLED Display with Arduino | Random Nerd Tutorials //