Project Logs

Collapse

• Week 8

  Neha • 06/09/2023 at 12:06 • 0 comments

  After last week's brainstorming and CAD designs, we printed out the CAD designs to test out on the watch strap to see if it will work or not. One thing we wanted to test was having two compartments on the watch strap. We made sure the compartments fit nicely into the strap. We found someone to try it on and see if it was comfortable. Surprisingly, the person said it felt good and didn't cause any problems. 

  We spent a lot of time working on the watch's program. We wanted the colors of the lights to change when you twist the dial, but we weren't sure how fast it should happen. So, we played around with the code to make the colors change at different speeds. After trying different settings, we found a speed that looked nice and didn't feel too fast or too slow. But then we had a different idea. Instead of just one fixed speed, we decided to let people choose their own speed. That way, everyone can set it to what they like best to make a more customizable experience especially since this product is made for children who may have varying preferences than others.
  

  We faced a little issue with the battery and its compartment being too big. It made the watch strap look bulky and not very comfortable despite what some people say. So, we started looking for a smaller battery that could fit nicely. Adafruit.com had a battery which seemed like it could be a nice fit. We did find out that it was much smaller, measuring only 19.75mm by 26.02mm by 3.8mm.

  We then ordered the new battery, we know this will make things fit much better than our current state. We can definitely see how this change could make a big difference in the overall design of our wristwatch. By reducing the size of the battery box on the strap, we aimed to create a more streamlined and comfortable experience for the wearer. The smaller battery would not only solve the bulkiness issue but also enhance the aesthetics of the watch, making it more appealing to users. We might even think about only having on compartment again like out previous designs, nut it really depends on how we distribute everything on the wrist band.
  

• Week 7

  Neha • 06/08/2023 at 19:07 • 0 comments

  We needed to find a solution that would keep our watch securely attached to the strap without the messiness of pipe cleaners. We wanted to find a balance between functionality and looks, ensuring that our design not only worked well but also looked pleasing. Next, we began sketching our ideas on paper. There were several possibilities which included gluing the box onto the strap or somehow taping it, but both of those ideas would end up looking messy like our previous idea with the pipe cleaners. Another challenge we had is how to properly hold the large battery as well and so with this, we decided to use two boxes rather than one that would wrap around the wrist, but we still didn’t know how to attach the boxes to the strap in a clean way. 

  After some time we came up with the idea of having the end of the strap go into a little space through the inside of the box then out the other (shown in the sketch) then fasten that end on the buckle like normal, this proved to be a great solution because it looked much smoother. We also had a little space for the wires to connect through the two boxes in a way where it didn’t fray or anything. After sketching we spent some time to CAD our initial design.

                                                         CAD Sketches and Finalization

  First, we have the box that will hold the battery. The battery is a bit large in size which does prove to be a challenge but we must make do until we have the time to order a new more compact one. You can see the hole above will be used to let the wires through into the next box, and the hole underneath that is used for the watch strap to slip right through creating a clean and smooth way to fasten it all together.
  

  Next, we have the box which we are planning to have it contain the rotary encoder with the dial on top. This will create some height but in order to have a big enough dial while also storing and organizing the other parts we will have to make it a bit tall. Once again the top hole is for the wires to be able to transfer right through to the other box or receive the wires, and the hole on the bottom will be used for the end of the watch strap to go through to pull it all together and make it fit nice and comfy.

  So this week we spent the majority of our time brainstorming so many different combinations of organizing and storing all the parts which proved to be a challenging task, but we did get this idea which turned out to be our best one. Our next step is to print the boxes out and test them and see if our idea will work the way we want it to or if we need to make any changes. We are questioning the idea of having two boxes on a singular wrist but we have to see it in order to really know if it'll be good or bad.

• Week 6

  Neha • 05/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 working on this project before presenting it. This week was when we put all of the 3-D parts that came from printing the cad files together. We also tried to figure out how to mount everything together without using pipe cleaners. Then a new cad was produced for new square boxes to put all the internals of the watch into, in order to encapsulate them. Another major improvement that was made was a little gap in the capsulation in order to thread the band of the watch through. Which gave us two boxes on the watch one on the top with the light and the dial, and putting the board into a separate box. The code was also altered to be sped up so the rotations of the dial with result in colors changing faster. This is an easily customizable product as the speed of the color shift is very customizable. Then all of the parts were put together.

  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, that can be found in the instructions and files in Hackaday. The code was also completed which can also be viewed in files. The code was edited to be faster so that a turn will result in the shift of a color faster than before The rotation will change the RGB value faster. Then we CADed a new case/capsulation, two of them. One to hold the dial and the lights, and other internals, which will do on the top of the watch band, and then another capsulation for the battery to hold the board and the battery. This will go on the side of the watch.  The last step was to put the product together (this is in the instructions).  The final product : 

• Week 5

  nallapumy • 05/09/2023 at 18:29 • 0 comments

  5Week 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() {
    Serial.begin(115200);
    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? ");
      Serial.println(version);
      while(1) delay(10);
    }
    Serial.println("Found Product 4991");
  
    // set not so bright!
    sspixel.setBrightness(20);
    sspixel.show();
    
    // 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");
    delay(10);
    ss.setGPIOInterrupts((uint32_t)1 << SS_SWITCH, 1);
    ss.enableEncoderInterrupt();
  }
  
  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));
      sspixel.show();
      encoder_position = new_position;      // and save for next round
    }
  
    // don't overwhelm serial port
    delay(10);
  }
  
  
  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...

  Read more »

• Week 4

  Neha • 05/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
  
  //encoder
  // 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.begin();
    strip.setBrightness(15);
    strip.show(); // Initialize all pixels to 'off'
  
  // Set encoder pins as inputs
    pinMode(CLK,INPUT);
    pinMode(DT,INPUT);
    pinMode(SW, INPUT_PULLUP);
  
    // Setup Serial Monitor
    Serial.begin(9600);
  
    // 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);
  
        strip.show();
  
      }
  
      Serial.print("Direction:...

  Read more »

• Week 3

  nallapumy • 05/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

  https://web.cecs.pdx.edu/~gerry/class/feather_sense/on-board/blinkNeoPixel/

  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 2

  Neha • 05/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 7 project logs