Mood Watch

A watch that can be used to describe emotions and their intensity. Twist the dial to control the color of the LED light.

Similar projects worth following
This mood watch is intended to be used for kids with extreme energy/ADHD or those who have trouble managing their emotions. It is used to help them control their emotions by visualizing their code through colors. As they twist the dial, they can see the intensity of their emotions through the colors of the rainbow. Their caretaker can use this to help them regulate their emotions and get back on track.

Audience: Caretakers of children who struggle to regulate their emotions
Purpose: Help teach children to visualize their emotions and regain control

Adobe Portable Document Format - 2.99 MB - 05/19/2023 at 18:12


Adobe Portable Document Format - 37.92 kB - 05/18/2023 at 23:11


Standard Tesselated Geometry - 68.05 kB - 05/18/2023 at 18:52


Standard Tesselated Geometry - 2.62 kB - 05/18/2023 at 18:51


  • Week 5

    Neha05/18/2023 at 18:47 0 comments

    uint32_t Wheel(byte WheelPos) {
      WheelPos = 255 - WheelPos;
      if (WheelPos < 85) {
        return sspixel.Color(255 - WheelPos * 3, 0, WheelPos * 3);
      if (WheelPos < 170) {
        WheelPos -= 85;
        return sspixel.Color(0, WheelPos * 3, 255 - WheelPos * 3);
      WheelPos -= 170;
      return sspixel.Color(WheelPos * 3, 255 - WheelPos * 3, 3);

    Week 5 is the final week of this project. 

    We finalized our 3D-printed parts, and our code, and put everything together. 

    Our 3D printed parts: 

                                                                             The Case

                                                                           The Dial

    The STL CAD Files can be found on the files section of our Hackaday, available for download and printing.

    Code (important snippet only: Check Files for the full code or in Week 4) 

    Week 5 summary: All of the design components were finalized and inserted into files. The code was also finalized which can also be viewed in files. The last step was to put the product together (this is in the instructions).  The final product : 

  • Week 4

    nallapumy05/09/2023 at 18:29 0 comments

    Week 4 summary:  Another version of the code was created, allowing for more changes in color in the color spectrum. After that was debugged and all the colors showed up, as well as all of the variables functioning properly, the code was modified to change colors faster through the encoder readings. The rate at which the colors changed was increased, making the process from shifting one color to another, easier.  A new cad was also developed to allow for the charge of the battery and the uploading of code, while also allowing all of the internals to fit into the encapsulation.

    After all of the parts arrived we quickly realized that the original CAD for the watch wouldn't be able to hold the internals of the watch because the measurements were off. We also haven't incorporated gaps in the CAD of the shell of the watch to allow for charging the watch and uploading code to it. Taking all of those pieces into consideration.  A rough outline for how the internals would be stacked on top of each other was made and measured producing out final CAD of the externals of the watch.

    Version 2 of the code to change the color of the LED based on the position of the dial.

    We used a variable that counts how many ticks the rotary encoder has turned and in which direction. We took the variable and called it counter and inserted it into the LED light to display the RBG value that dictates the color that's going to show. Nupur made a function for when the dial gets turned it makes another variable go down/up depending on the encoder readings. In order to make the LED change colors faster with fewer dial rotations, we multiplied the counter value by 10.

     * This example shows how to read from a seesaw encoder module.
     * The available encoder API is:
     *      int32_t getEncoderPosition();
            int32_t getEncoderDelta();
            void enableEncoderInterrupt();
            void disableEncoderInterrupt();
            void setEncoderPosition(int32_t pos);
    #include "Adafruit_seesaw.h"
    #include <seesaw_neopixel.h>
    #define SS_SWITCH        24
    #define SS_NEOPIX        6
    #define SEESAW_ADDR          0x36
    Adafruit_seesaw ss;
    seesaw_NeoPixel sspixel = seesaw_NeoPixel(1, SS_NEOPIX, NEO_GRB + NEO_KHZ800);
    int32_t encoder_position;
    void setup() {
      while (!Serial) delay(10);
      Serial.println("Looking for seesaw!");
      if (! ss.begin(SEESAW_ADDR) || ! sspixel.begin(SEESAW_ADDR)) {
        Serial.println("Couldn't find seesaw on default address");
        while(1) delay(10);
      Serial.println("seesaw started");
      uint32_t version = ((ss.getVersion() >> 16) & 0xFFFF);
      if (version  != 4991){
        Serial.print("Wrong firmware loaded? ");
        while(1) delay(10);
      Serial.println("Found Product 4991");
      // set not so bright!
      // use a pin for the built in encoder switch
      ss.pinMode(SS_SWITCH, INPUT_PULLUP);
      // get starting position
      encoder_position = ss.getEncoderPosition();
      Serial.println("Turning on interrupts");
      ss.setGPIOInterrupts((uint32_t)1 << SS_SWITCH, 1);
    void loop() {
      if (! ss.digitalRead(SS_SWITCH)) {
        Serial.println("Button pressed!");
      int32_t new_position = ss.getEncoderPosition();
      // did we move arounde?
      if (encoder_position != new_position) {
        Serial.println(new_position);         // display new position
        // change the neopixel color
        sspixel.setPixelColor(0, Wheel(new_position & 0xFF));;
        encoder_position = new_position;      // and save for next round
      // don't overwhelm serial port
    uint32_t Wheel(byte WheelPos) {
      WheelPos = 255 - WheelPos;
      if (WheelPos < 85) {
        return sspixel.Color(255 - WheelPos * 3, 0, WheelPos * 3);
      if (WheelPos < 170) {
        WheelPos -= 85;
        return sspixel.Color(0, WheelPos * 3, 255 - WheelPos * 3);
      WheelPos -= 170;
      return sspixel.Color(WheelPos * 3, 255 - WheelPos * 3, 3);

    This revised code of version 2 allows the color to change more frequently with fewer turns of the dial.

    if ((multiplier...
    Read more »

  • Week 3

    Neha05/02/2023 at 18:25 0 comments

    Week 3 summary: The Adafruit feather adalogger was set up and wired to the encoder and LED. This is what will be used to test the code and troubleshoot. The coding process was also started. Our code in short displays different RGB values when the encoder is turned. Each of the RGB (red, blue, green) values changes based on different positions of the encoder. We viewed those encoder readings this week and were pleased to see the LED change color, as that indicates that our code is working, though it may be just a few colors at the start.

    Week 3's logs

    We wired the encoder and LED to the Aurdino. We are using these parts to test and experiment with code while waiting for the actual materials to arrive. This encoder, LED, and Aurdino will help us complete and troubleshoot the code.

    These are the encoder readings. The value changes by one every click when the dial is being rotated. These encoder readings also change the color gradually by increasing or decreasing each of the RGB color concentrations. This gradually changes the colors.

    Our code for when we put the encoder position into the RGB value to change the color of the LED. This code affects the encoder position to manipulate the value of the concentration of each color in RGB, such as Red Green Blue. As the encoder position increases different variables of RBG are also manipulated. All of this affects the color of the LED.

    Version 1 of code, still in progress.

    #include <Adafruit_NeoPixel.h>
    // Which pin on the Arduino is connected to the NeoPixels?
    // On a Trinket or Gemma we suggest changing this to 1:
    #define LED_PIN    10
    // How many NeoPixels are attached to the Arduino?
    #define LED_COUNT 32
    // Declare our NeoPixel strip object:
    Adafruit_NeoPixel strip(LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800);
    // Argument 1 = Number of pixels in NeoPixel strip
    // Argument 2 = Arduino pin number (most are valid)
    // Argument 3 = Pixel type flags, add together as needed:
    //   NEO_KHZ800  800 KHz bitstream (most NeoPixel products w/WS2812 LEDs)
    //   NEO_KHZ400  400 KHz (classic 'v1' (not v2) FLORA pixels, WS2811 drivers)
    //   NEO_GRB     Pixels are wired for GRB bitstream (most NeoPixel products)
    //   NEO_RGB     Pixels are wired for RGB bitstream (v1 FLORA pixels, not v2)
    //   NEO_RGBW    Pixels are wired for RGBW bitstream (NeoPixel RGBW products
    // Rotary Encoder Inputs
    #define CLK 13
    #define DT 12
    #define SW 6
    int counter = 0;
    int updatedcounter = 0;
    int currentStateCLK;
    int lastStateCLK;
    String currentDir ="";
    unsigned long lastButtonPress = 0;
    void setup() {
      strip.setBrightness(15);; // Initialize all pixels to 'off'
    // Set encoder pins as inputs
      pinMode(SW, INPUT_PULLUP);
      // Setup Serial Monitor
      // Read the initial state of CLK
      lastStateCLK = digitalRead(CLK);
    void loop()  {
          // Read the current state of CLK
      currentStateCLK = digitalRead(CLK);
      // If last and current state of CLK are different, then pulse occurred
      // React to only 1 state change to avoid double count
      if (currentStateCLK != lastStateCLK  && currentStateCLK == 1){
        // If the DT state is different than the CLK state then
        // the encoder is rotating CCW so decrement
        if (digitalRead(DT) != currentStateCLK) {
          counter --;
          currentDir ="CCW";
        } else {
          // Encoder is rotating CW so increment
          counter ++;
          currentDir ="CW";
                updatedcounter = counter * 4;
          strip.setPixelColor(3, rgbA, rgbB, rgbC);
    Read more »

  • Week 2

    nallapumy05/01/2023 at 18:54 0 comments

    Adafruit Feather Logger

    We started using an Adafruit Feather Adalogger to use and test our code before getting the parts that are running late.

    Temporary Arduino Dimensions

    Arduino dimensions for the practice one while we wait for ours to come.

    Arduino Guide

    We used this link to help us set up the Arduino ID. Used it as a guide.

    Dial and Base Plate

    Here is a screenshot of a CAD of both the dial and baseplate of the watch together. This is how they will fit. Will hold the encoder and battery.

    Week 2 summary: This week on our project, the two parts of the CAD were put together, displaying what we hope the final product of the top part of the watch will look like. The Ada fruit feather adalogger was also set up to start the coding process.  The code will be tested on the Ada fruit feather adalogger as we wait for the parts of the watch to arrive, to ensure the code works, and to find any errors before transferring it to the actual pieces of the watch.

  • Week 1

    Neha05/01/2023 at 18:29 0 comments

    This was the initial outline for our watch. This was right after we interviewed multiple assistive technology professionals, and learned about their needs to help improve assistive technology for students and adults with disabilities.

    These are the parts that we decided to order for our project. The rotary encoder and the Qt Py are the two parts that we purchased from Adafruit. The watch strap was purchased by our teacher. We decided on using that rotary encoder so that we could manipulate the color of the LED by the position of the encoder.

    Here we finished the CAD for the clear dial that would cover the encoder, while also allowing the light from the LED to shine through it.

    We got a wristband for our watch which will secure the mood watch onto the user's wrist.

    Here is the CAD for the base plate of our watch. This will serve as a base in which all the internals will be encapsulated.

    Week 1 summary:

    In the first week of this project, we met with some professionals from the assistive technology department and talked to them about some challenges that people they interact with face. After compiling many ideas and challenges thrown out from different interviews. We agreed on making a watch, which would change colors gradually based on the position of the dial, or how many times the dial is spun. After that, we made a project proposal about our idea and got it confirmed by our teacher. We then made a list of materials we needed and started ordering those after talking to our teacher. While we waited for the materials to get here a member of our team took the measurements for the internals that were on the Adafruit website from where we purchased the parts, of the watch and designed a CAD for dial that would help the user to change the position of the encoder while also allowing the changes of light to shine through it.  Another CAD that was made was for the baseplate which was made to encapsulate the internals of the watch. Then the watch strap arrived.

View all 5 project logs

  • 1

    Materials: Arduino QT PY, Lithium Ion Polymer Battery, Adafruit I2C Stemma QT Rotary Encoder Breakout (rotary encoder/LED), Foam, Pipe cleaners, Dial, Case (3D printed: file in files area), Watch strap

  • 2
    Step 1

    Place the battery and QT PY into the case like so.

  • 3
    Step 2

    Push the foam into the middle of the battery and QT PY to give them a tight fit.

View all 6 instructions

Enjoy this project?



Similar Projects

Does this project spark your interest?

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