CubexStress

Description

"Find tranquillity in the palm of your hand with our stress-relief toy – where relaxation meets playfulness."

This project is lead by Clémence and Julian. Two engineering students at ESME, looking to help to reduce the stress of students.

Our Objectives :
To create a fidget toy designed to help individuals who experience anxiety and stress in their daily lives.

Our Project Description:
Our project focuses on developing a fun, interactive, and portable fidget toy that provides a tangible outlet for anxiety and stress relief. \

Key Features: Interactive, Portable and Fun.

Target Audience:
People of all ages who experience anxiety and stress, particularly those looking for an effective and convenient coping mechanism.

Our fidget toy aims to offer a practical solution for managing anxiety and stress, enhancing the well-being of users through its enjoyable, engaging, and easily portable design.

Details

Our objective is to create an interactive experience for anxious people so that they feel more calm and comfortable in stressful environments.

Our product is an anti-stress toy that is :

Fun to play with
Interactif
Modular
Portable

overall systems :

Piano

Summary :

The portable piano with 5 musical notes ( do re mi fa sol ). With this piano you can express your creative side and play nealry every song possible.

Electronic :

The Piano has two main parts :

5x Buttons (Inputs)
1x Passive Buzzer (Outputs)

3 wheels

Summary :

allows you to express your visual thoughts by changing each individual values of the color spect. You have the choice for more than 16.7M different colour’s to express your emotions, your mood and much more.

Electronic :

The wheels three main parts :

4x Hall effect sensors (inputs)
1x Lever button (input)
1x LED RGB strip (output)

The Snake game

Summary :

-Snake is one of the most known Game is one that exists, so we decided to bring you the game on board our custom fidget toy.

Electronic :

The wheels two main parts :

1x Joystick (inputs)
1x 8x8Matrix LED screen (output)

Modules

Summary : Modular and customisable (low tech)

This part consists for you to engage your creativity and create your own little game, that allows you express your sense of creativity and imagination.

3 different Modules :

1x Maze
1x Power 4
1x bottle game

PS : Hope that our school will help some of you to cope with the stress of study and work a little better.

Files

Version_Final_Matrix_and_Piano_.ino

Arduino code for the Piano module and the Matrix module in a single code

- 3.08 kB - 05/29/2024 at 12:24

Download

Light Bubl V2.gcode

Light Bubl concept V2 - 3D printing code for Printer Optimisation + correction

gcode - 2.99 MB - 03/20/2024 at 21:02

Download

MAZE SVG - THURSDAY20OFMARCH.svg

Blue Print MAZE - Laser Cutter

svg+xml - 47.00 kB - 03/20/2024 at 19:02

Download

Julian - Threads TEST.gcode

Gcode 3D printing Threads testing / prototype roughly 1h21 minutes

gcode - 3.68 MB - 03/13/2024 at 20:22

Download

Julian - Gear TEST.gcode

Gcode 3D prining gear roughly 35 minutes

gcode - 2.21 MB - 03/13/2024 at 20:22

Download

Components

1 × Arduino nano Main Brain of our project

5 × Simple push buttons Used for Piano

1 × Passive Buzzer Used for Piano

1 × Joystick Used for Snake

1 × 8x8 matrix LED Screen Used for Snake

Project Logs

Collapse

Phase 3 - 18/04/2024 TO 2/05/2024
julian.baron • 3 days ago • 0 comments

Piano and Buzzer
Phase 2 - 3D modeling and Codind - 21/03/2024 to 11/03/2024
julian.baron • 3 days ago • 0 comments
Phase 2 - Testing and Implementation: This phase was focused on ensuring that the 3D models and code worked together effectively to create a functional and reliable product.
- 3D Modelling: We used CAD software (Fusion 360) to create detailed 3D models of the fidget toy. These models were then used to 3D print physical prototypes. We tested these prototypes for ergonomics, durability, and user satisfaction.
- Code Integration: We developed and tested the software necessary to operate the toy’s electronic components, ensuring that the mini piano, snake game, light bulb, wheels, and changeable RGB bulb functioned as intended. This included debugging and refining the code to achieve seamless operation.
1. Designing and 3 Modelling

Gear

Threads

2. Electronic and Code Integration

Home-made Rotary encoder
Phase 4 - 2/05/2024 to 16/06/2024
julian.baron • 3 days ago • 0 comments

• Final Phase: Refinement and Production:
In this phase, we focused on finalizing the design and preparing for mass production. Key activities included:
• Design Refinement:
Based on feedback from the testing phase, we made final adjustments to both the physical design and the software. This involved enhancing the user interface, improving the durability of components, and ensuring the toy is as user-friendly as possible.
• Material Selection:
We selected the best materials for mass production, balancing cost, durability, and user comfort. This included choosing high-quality plastics, reliable electronic components, and safe, non-toxic finishes.
• Quality Assurance:
We implemented a thorough quality assurance process to ensure each toy met our high standards. This included rigorous testing of each unit for functionality, durability, and safety.
• Production Planning:
We developed a detailed plan for mass production, including sourcing suppliers, setting up manufacturing processes, and establishing distribution channels.

Conclusion:
Our fidget toy project has successfully progressed through several critical phases, each aimed at ensuring the final product meets the needs of users who experience anxiety and stress. By focusing on both the technical and physical aspects of the toy, we have created a product that is not only functional but also enjoyable and easy to use. The final phase of refinement and production has ensured that the toy is ready for market, with high-quality standards maintained throughout the process.

Key Takeaways:

• Holistic Design Approach: By integrating user feedback, rigorous testing, and iterative improvements, we ensured that the toy addresses the real needs of individuals seeking stress relief.
• Quality and Durability: Our focus on quality assurance and material selection guarantees a durable and reliable product.
• User-Centric Features: The combination of fun, interactive, and portable elements makes the toy highly appealing and effective for our target audience.

Future Directions:

• Market Launch: With the final product ready, the next steps include marketing, distribution, and gathering post-launch feedback to further refine the product.
• Feature Expansion: Based on user feedback, we may consider adding new features or developing additional modules to enhance the toy’s functionality and appeal.

Our fidget toy aims to offer a practical solution for managing anxiety and stress, enhancing the well-being of users through its enjoyable, engaging, and easily portable design. By integrating various interactive features, rigorously testing the prototypes, and prioritizing both electronics/programming and modeling/build, we ensure a high-quality final product that caters to different preferences and needs.

Feel free to adjust or expand on any sections as needed!
Phase 1 - Rapid Prototyping 14/03 - 21/03
julian.baron • 03/20/2024 at 21:04 • 0 comments
Phase rapid prototyping :

     1.Modelling the prototype for a light bulb :

The light bulb is just a prof of concept so that you can create your own custom design for your light bulb, this light can be changed through the 3 gears on the side : each gears represents the following colours RED, GREEN and BLUE.

Here is the basic design that we have 3D modelled

     2.Modelling the prototype for the gears :

First design of a gear and it's axel : Crucial part was how to fix a rotating wheel with an axis

   3. Prototype of the first changeable Module - The great maze

We wanted to create a fun and always loved game the mazes to entrain you during your commutes or even at work ( don't tell your boss that you got the greatest of toys hahah )

The maze is one of the three module that we will propose.
4. Coding Snake game

This a one of the most famous game in the just in the size of your hands,

The code of snake is in process....Pleaseeeee wait Thanks

5. Preparing to Order Parts

- Panification of our new needs to continue our project.
Phase 1 - Rapid Prototyping 7/03/2024 to 13/03/05
julian.baron • 03/13/2024 at 19:01 • 0 comments
Phase 1 - Fast prototyping

This Phase consisted on testing and doing proofs of concept to have a better build final product

Testing and Proof of Concept Phase: In this phase, we conducted various tests and developed proofs of concept to refine the design and functionality of the fidget toy. This involved:
- User Testing: Gathering feedback from potential users to understand their preferences and areas of improvement.
- Prototype Development: Creating and evaluating multiple prototypes to identify the best materials, dimensions, and feature integrations.
- Functionality Testing: Ensuring that all interactive components work seamlessly and contribute effectively to anxiety and stress relief.
- Iterative Improvements: Making continuous adjustments based on testing outcomes to enhance the final product’s build quality and user experience.
1. Down sizing the box

Our last prototype was 150x150x150 this size was unpracticable and way to big to use. we decided to make it smaller and way way better than the last time, get ready for the greatest toy that will have in your hands.

Our goal during this stage is to make sure that every module works perfectly together and that the down sizing of the project is first possible by dividing the volume by 2 (20%).

For rapid prototyping we will use the laser cuter for the big parts like the box.

2. Deciding on our priorities

We identified two crucial aspects of our project to ensure its success:
- Electronics and Programming: This aspect focused on the integration and functionality of electronic components and the development of software to control interactive features.
  - Electronics: We selected and tested components such as microcontrollers, sensors, and LEDs to ensure reliable performance and compatibility.
  - Programming: We developed and refined software for the mini piano, snake game, and other interactive elements. This included coding for responsiveness, user interface, and ensuring seamless integration between hardware and software.
- Modeling and Build: This aspect focused on the physical design and construction of the fidget toy to ensure it is ergonomic, durable, and aesthetically pleasing.
  - Modeling: Using CAD software, we designed the toy's physical structure, ensuring it was both compact and user-friendly. We paid special attention to the placement of electronic components to optimize functionality and ease of use.
  - Build: We created prototypes using various materials to test the design's practicality and durability. This involved 3D printing and other fabrication techniques to produce a high-quality final product.

Phase 0 - Specifications - 29/02 to 7/03

julian.baron • 03/13/2024 at 16:16 • 0 comments

Phase 0 - Specifications :

Project Overview - Create an interactive experience for anxious people.

Our objective is to create an interactive experience for anxious people so that they feel more calm and comfortable in stressful environments.

Our product is an anti-stress toy that is :

Fun to play with
Interactif
Modular
Portable

Scope - Updating old prototype

Specification Phase: During this phase, we determined the optimal size for the fidget toy and outlined its primary features. Our goal was to ensure the toy is both functional and convenient to carry. The features we decided on include.

Parts kept :

Piano ( 5 buttons to plays sounds )
Gears ( 3 gears that allows to change LED RGB colours )
Light Bulb

Parts left out :

Distance sensor ( changing the brightness of the light )
interactive Art ( Servo Motors + Joystick)

New Parts added :

Snake game ( joystick and
Customizable module

Functional Requirements - Project requirements - Organization and Planning

	Functional requirements	Non-functional requirements
Objective	Piano, Gears, Modules	aesthetic
End Results	finished product ready for production	looks
Focus	Functional electronics and final product done	Easy to fix
Essentials	Piano, Gears, Light Bulb, Modules	easy to enter the box
Testing	Code, Fast prototyping	structural capability
Validations	NEEDS TO WORK

View all 6 project logs

Build Instructions

Collapse

Build box and woodend structures

Wooden parts will be cut with the laser cuter

PS : The thickness of the wood used for this project was 3mm !!!! BE AWARE !!!

Main part - Box : 600 cm2 ( Box.SVG SVG file are available on the file section)

Secondary Module Maze (Add On) : 300 cm2 ( Maze.SVG SVG file are available on the file section)

Secondary Module Power 4 (Add On) : 300 cm2 ( Power4.SVG SVG file are available on the file section)

Secondary Module Bottle challenge (Add On) : 200cm2 ( Power4.SVG SVG file are available on the file section)

Mandatory part - Support for the gears : 200cm2 ( Support.SVG SVG file are available on the file section)

Electronics

We used a Arduino nano card for our project

You can find it through this link : Arduino nano

Arduino nano chip and board

Beginner pin mapping - Microcontrollers - Arduino Forum

1. The piano

5x Simple push Buttons
1x Passive Buzzer
5x resistor : 10kOhms
6 Digital pins ( 5 inputs and 1 output)
Power 5V+

2. Rotary encoder and RGB bulb

4x Hall Effect sensor
1x lever button
5x resistor : 10kOhms
1x LED RGB Strip
6 pins ( 5 inputs and 1 output )
Power 5V+

Schematic

3. Snake

1x Joystick
1x Matrix LED 8x8 screen
?? pins ( ?? inputs and ??? outputs )
Power 5V+

Coding

1. The piano

This code is for the Piano

Pins Buttons are digital pins : 3,4,6,7,8

Pins Passive Buzzer : 9

#include <Wire.h>
#include "Adafruit_LEDBackpack.h"
#include "Adafruit_GFX.h"

#define JOYSTICK_X_PIN A0
#define JOYSTICK_Y_PIN A1
#define BUTTON_PIN 2 // Broche où est connecté le bouton 2Pcs

Adafruit_8x8matrix matrix = Adafruit_8x8matrix(); // Utilisation de la classe Adafruit_8x8matrix pour la matrice LED
uint8_t x = 0;
uint8_t y = 0;

const int boutonPin1 = 8;
const int boutonPin2 = 3;
const int boutonPin3 = 4;
const int boutonPin4 = 6;
const int boutonPin5 = 7;
const int buzzerPin = 9;

int etatBouton1 = 0; 
int etatBouton2 = 0;
int etatBouton3 = 0; 
int etatBouton4 = 0; 
int etatBouton5 = 0; 

void setup() {
  Serial.begin(9600);
  Serial.println("Joystick and Buttons Test");

  matrix.begin(0x70); // Initialisation de la matrice LED
  pinMode(BUTTON_PIN, INPUT_PULLUP); // Bouton poussoir du joystick en entrée avec résistance de pull-up interne

  pinMode(boutonPin1, INPUT);  
  pinMode(boutonPin2, INPUT);  
  pinMode(boutonPin3, INPUT);  
  pinMode(boutonPin4, INPUT);  
  pinMode(boutonPin5, INPUT);  
  pinMode(buzzerPin, OUTPUT); // Met le buzzer en mode sortie

  digitalWrite(buzzerPin, LOW); 
}


void clearDisplay() {
  for (uint8_t i = 0; i < 8; i++) {
    matrix.displaybuffer[i] = 0;
  }
}


void loopJoystick() {
  int xValue = analogRead(JOYSTICK_X_PIN);
  int yValue = analogRead(JOYSTICK_Y_PIN);

  // Calibrer les valeurs de l'axe X et Y
  if (xValue < 400 && x > 0) {
    x--;
  } else if (xValue > 600 && x < 15) {
    x++;
  }

  if (yValue < 400 && y > 0) {
    y--;
  } else if (yValue > 600 && y < 7) {
    y++;
  }

  // Mettre à jour l'affichage
  clearDisplay();
  matrix.displaybuffer[y] |= (1 << x);
  matrix.writeDisplay();
  delay(200); // Ajouter un délai pour contrôler la vitesse du mouvement
}


void loopButtons() {
  // Lecture des états des boutons et contrôle du buzzer
  int etatBoutonActuel = digitalRead(boutonPin2);
  if (etatBoutonActuel != etatBouton2) {
    delay(50);
    etatBouton2 = etatBoutonActuel;
    if (etatBouton2 == LOW) {
      noTone(buzzerPin);
    } else {
      tone(buzzerPin, 293);
    }
  }

  int etatBoutonActuel1 = digitalRead(boutonPin1);
  if (etatBoutonActuel1 != etatBouton1) {
    delay(50);
    etatBouton1 = etatBoutonActuel1;
    if (etatBouton1 == LOW) {
      noTone(buzzerPin);
    } else {
      tone(buzzerPin, 261);
    }
  }

  int etatBoutonActuel2 = digitalRead(boutonPin3);
  if (etatBoutonActuel2 != etatBouton3) {
    delay(50);
    etatBouton3 = etatBoutonActuel2;
    if (etatBouton3 == LOW) {
      noTone(buzzerPin);
    } else {
      tone(buzzerPin, 329);
    }
  }

  int etatBoutonActuel3 = digitalRead(boutonPin4);
  if (etatBoutonActuel3 != etatBouton4) {
    delay(50);
    etatBouton4 = etatBoutonActuel3;
    if (etatBouton4 == LOW) {
      noTone(buzzerPin);
    } else {
      tone(buzzerPin, 348);
    }
  }

  int etatBoutonActuel4 = digitalRead(boutonPin5);
  if (etatBoutonActuel4 != etatBouton5) {
    delay(50);
    etatBouton5 = etatBoutonActuel4;
    if (etatBouton5 == LOW) {
      noTone(buzzerPin);
    } else {
      tone(buzzerPin, 392);
    }
  }
}


void loop() {
  
  loopButtons();
  loopJoystick();
  
}

2. Rotary encoder and RGB bulb

hall effect Sensors :

// Define pins for Hall effect sensors
const int hallSensor1Pin = 2;
const int hallSensor2Pin = 3;
// Define pins for RGB LED
const int redPin = 9;
const int greenPin = 10;
const int bluePin = 11;


// Variables to keep track of the state of the sensors
int state1 = LOW;
int state2 = LOW;
int lastState1 = LOW;
int lastState2 = LOW;
int count = 0;


// Define a brightness factor (range 0.0 to 1.0)

const float brightness = 0.5; // 50% brightness


void setup() {
 // Initialize sensor pins
 pinMode(hallSensor1Pin, INPUT);
 pinMode(hallSensor2Pin, INPUT);
 // Initialize LED pins
 pinMode(redPin, OUTPUT);
 pinMode(greenPin, OUTPUT);
 pinMode(bluePin, OUTPUT);
 // Start serial communication for debugging
 Serial.begin(9600);
}
void loop() {
  
 // Read the state of the sensors
 int sensor1State = digitalRead(hallSensor1Pin);
 int sensor2State = digitalRead(hallSensor2Pin);
 // Determine the direction of rotation
 
 if (sensor1State != lastState1 || sensor2State != lastState2) {
   if (lastState1 == LOW && sensor1State == HIGH) {
     // Rising edge on sensor 1
     if (sensor2State == LOW) {
       count++;
       
     } else {
       count--;
     }
     
   } else if (lastState1 == HIGH && sensor1State == LOW) {
     // Falling edge on sensor 1
     if (sensor2State == HIGH) {
       count++;
     } else {
       count--;
     }
   } else if (lastState2 == LOW && sensor2State == HIGH) {
     // Rising edge on sensor 2
     if (sensor1State == HIGH) {
       count++;
     } else {
       count--;
     }
   } else if (lastState2 == HIGH && sensor2State == LOW) {
     // Falling edge on sensor 2
     if (sensor1State == LOW) {
       count++;
     } else {
       count--;
     }
   }
 }

 
 // Save the last state of the sensors
 lastState1 = sensor1State;
 lastState2 = sensor2State;

 
 // Calculate RGB values based on count
 int red = (abs(count) * 10) % 256;
 int green = (abs(count) * 5) % 256;
 int blue = (abs(count) * 2) % 256;


 
 // Apply brightness factor
 
 red = (int)(red * brightness);
 green = (int)(green * brightness);
 blue = (int)(blue * brightness);

 
 // Set the RGB LED color
 analogWrite(redPin, red);
 analogWrite(greenPin, green);
 analogWrite(bluePin, blue);
 
 // Print the count and RGB values for debugging

 
 Serial.print("Count: ");
 Serial.print(count);
 Serial.print("  Red: ");
 Serial.print(red);
 Serial.print("  Green: ");
 Serial.print(green);
 Serial.print("  Blue: ");
 Serial.println(blue);
 delay(100); 
 // Small delay for stability
}

Lever Button

#include <Adafruit_NeoPixel.h>

// Define the pin where the lever switch is connected
const int leverSwitchPin = 2;
// Variable to store the lever switch state
int leverSwitchState = 0;
int countlever = 0;

// Number of LEDs in your strip
const int numPixels = 3;

// Data pin for the RGB LED strip
const int dataPin = 10;

// Create an instance of the Adafruit_NeoPixel class
Adafruit_NeoPixel strip = Adafruit_NeoPixel(numPixels, dataPin, NEO_GRB + NEO_KHZ800);

void setup() {
  // Initialize the lever switch pin as an input
  pinMode(leverSwitchPin, INPUT);
  
  // Initialize serial communication for debugging
  Serial.begin(9600);

  // Initialize the RGB LED strip
  strip.begin();
  strip.show(); // Initialize all pixels to 'off'
}

void loop() {
  // Read the state of the lever switch
  leverSwitchState = digitalRead(leverSwitchPin);
  
  // Print the state of the lever switch to the Serial Monitor
  if (leverSwitchState == HIGH) {
    Serial.println("Lever switch is OPEN");
  } else {
    Serial.println("Lever switch is CLOSED");
    countlever++;
  }
  
  // Calculate RGB values based on count
  int red = (abs(countlever) * 0) % 256;
  int green = (abs(countlever) * 5) % 256;
  int blue = (abs(countlever) * 0) % 256;
  
  // Set the color of all LEDs in the strip
  for (int i = 0; i < numPixels; i++) {
    strip.setPixelColor(i, 0, green, 0);
  }
  strip.show(); // Update the strip with the new color
  
  // Print the count and RGB values for debugging
  Serial.print("count: ");
  Serial.print(countlever);
  Serial.print("  green: ");
  Serial.print(green);
  
  // Small delay for stability
  delay(20); 
}

3. Snake

Discussions

CubexStress

Description

Details

Files

Version_Final_Matrix_and_Piano_.ino

Light Bubl V2.gcode

MAZE SVG - THURSDAY20OFMARCH.svg

Julian - Threads TEST.gcode

Julian - Gear TEST.gcode

Components

Project Logs

Collapse

Phase 3 - 18/04/2024 TO 2/05/2024

Phase 2 - 3D modeling and Codind - 21/03/2024 to 11/03/2024

Phase 4 - 2/05/2024 to 16/06/2024

Phase 1 - Rapid Prototyping 14/03 - 21/03

Phase 1 - Rapid Prototyping 7/03/2024 to 13/03/05

Phase 0 - Specifications - 29/02 to 7/03

Build Instructions

Collapse

Discussions

Similar Projects

OHMni-Stick

Tea Dunker STEM / STEAM Project

D-Grip

Lighting Score

CubexStress

Become a Hackaday.io member

Just one more thing

Description

Details

Files

Components

Project Logs Collapse

Build Instructions Collapse

Enjoy this project?

Discussions

Become a Hackaday.io Member

Similar Projects

Does this project spark your interest?

Report project as inappropriate

Send message

Remove Member

Project Logs

Collapse

Build Instructions

Collapse