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

Public Chat
Similar projects worth following
"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.

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 :


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. 


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)


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.


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

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


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



Blue Print MAZE - Laser Cutter

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


Julian - Threads TEST.gcode

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

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


Julian - Gear TEST.gcode

Gcode 3D prining gear roughly 35 minutes

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


View all 9 files

  • 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

View all 13 components

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

    julian.baron05/29/2024 at 21:23 0 comments

    Piano and Buzzer

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

    julian.baron05/29/2024 at 20:52 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



    2. Electronic and Code Integration

    Home-made Rotary encoder

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

    julian.baron05/29/2024 at 20:39 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.

    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.baron03/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.

      Laser Cutting 21st of march

    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.baron03/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.baron03/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
    ObjectivePiano, Gears, Modules
    End Results
    finished product ready for production
    FocusFunctional electronics and final product done
    Easy to fix
    Piano, Gears, Light Bulb, Modules
    easy to enter the box
    TestingCode, Fast prototyping
    structural capability
    ValidationsNEEDS TO WORK

View all 6 project logs

  • 1
    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)

    Total of wood needed for the project : 1600 cm2

  • 2

    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+
    Schematic for Piano

    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+


    3. Snake

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

       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.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) {
      } else if (xValue > 600 && x < 15) {
      if (yValue < 400 && y > 0) {
      } else if (yValue > 600 && y < 7) {
      // Mettre à jour l'affichage
      matrix.displaybuffer[y] |= (1 << x);
      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) {
        etatBouton2 = etatBoutonActuel;
        if (etatBouton2 == LOW) {
        } else {
          tone(buzzerPin, 293);
      int etatBoutonActuel1 = digitalRead(boutonPin1);
      if (etatBoutonActuel1 != etatBouton1) {
        etatBouton1 = etatBoutonActuel1;
        if (etatBouton1 == LOW) {
        } else {
          tone(buzzerPin, 261);
      int etatBoutonActuel2 = digitalRead(boutonPin3);
      if (etatBoutonActuel2 != etatBouton3) {
        etatBouton3 = etatBoutonActuel2;
        if (etatBouton3 == LOW) {
        } else {
          tone(buzzerPin, 329);
      int etatBoutonActuel3 = digitalRead(boutonPin4);
      if (etatBoutonActuel3 != etatBouton4) {
        etatBouton4 = etatBoutonActuel3;
        if (etatBouton4 == LOW) {
        } else {
          tone(buzzerPin, 348);
      int etatBoutonActuel4 = digitalRead(boutonPin5);
      if (etatBoutonActuel4 != etatBouton5) {
        etatBouton5 = etatBoutonActuel4;
        if (etatBouton5 == LOW) {
        } else {
          tone(buzzerPin, 392);
    void loop() {


    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
    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) {
         } else {
       } else if (lastState1 == HIGH && sensor1State == LOW) {
         // Falling edge on sensor 1
         if (sensor2State == HIGH) {
         } else {
       } else if (lastState2 == LOW && sensor2State == HIGH) {
         // Rising edge on sensor 2
         if (sensor1State == HIGH) {
         } else {
       } else if (lastState2 == HIGH && sensor2State == LOW) {
         // Falling edge on sensor 2
         if (sensor1State == LOW) {
         } else {
     // 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("  Red: ");
     Serial.print("  Green: ");
     Serial.print("  Blue: ");
     // 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
      // Initialize the RGB LED strip
      strip.begin();; // 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");
      // 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);
      }; // Update the strip with the new color
      // Print the count and RGB values for debugging
      Serial.print("count: ");
      Serial.print("  green: ");
      // Small delay for stability

    3. Snake

View all 4 instructions

Enjoy this project?



Similar Projects

Does this project spark your interest?

Become a member to follow this project and never miss any updates