Final Project¶

The original Final Project consisted of many projects. With guidance from my Instructors, Pablo Nunez and Adrian Torres, as well as Rico Kanthatham the scope needs to be reduced. All progress toward the Final Project will be archived in the Project Development page. Content related to Managing Projects as presented by Norella Coronell and May El-Dardiry will be listed on this Final Project page.

2 deliverables per week, one regarding the assignment (Globally) and the other the ﬁnal project (Locally)

W4 Concept Plan¶

Potential ideas for your final project with General Brainstorm and discussion with your local instructor.
Helps cancel unreachable ideas.

During Week 1 and Week 2, I thought about my final project idea and started getting used to the documentation process. I will update this page as the idea transforms.

Communication of an initial project proposal¶

Introduction:

The initial project proposal has the intent of communicating the ultimate Final Project that I will be able to make after completing the 20 weeks of learning leading up to its completion. After discovering the Fab Academy, the prospect of being able make (almost) anything enables me to think of many ideas I have only dreamed of making before this time.

The projects that I complete as I work toward the Final Project will allow me to explore the possibilities, as well as refine the vision of the Final Project.

Scenario:

The greatest attraction that guided me to the Fab Academy was the desire to build a wooden sailboat; something that has been too lofty for my skill set. While this may be too ambitious for the timeframe allotted, a cardboard boat may be a more doable project.

Although a cardboard boat would be feasible, it only produces the first 3 outcomes, without producing the fourth: “Demonstrate competence in design, fabrication and programming of my own fabbed microcontroller PCB, including an input & output device”. To produce the fourth outcome, I propose making a wearable information and navigation device; one that would keep a sailor informed while underway.

While most of the parts will be obtained from existing resources, new and reused, the goal to design and fabricate my own parts instead of buying off-the-shelf components will be accomplished in the wearable information device.

As this work progresses, the projects of each week will be explored while the results will be incorporated into this project; the refinement of the results will insure the development of the carboard boat and wearable device as well as the following deliverables:

Slide: 1920 x 1080 pixels with your name, project name, Fab Lab name, a photo/render/sketch of your project, a brief description of what your project is/does
~1 minute (10MB/1080p/720p) video of you explaining your project
Separate Final Project page that briefly summarizes your project and
BOM (Bill of Materials) for your project
Links of page to any weeks that I worked on my final project
Links to my presentation.png and presentation.mp4
All original design files in the archive (2D & 3D, board files & code) No external hosting of final project files
The license I chose
Acknowledgement of work done by others

Deliverables:¶

Assignment

Post the Initial Project Proposal on my Fab Academy site

Since this Final Project Plan begins with Week 4, the other assignments (Global) have been completed and documented on the following pages:

W1 Principles and Practices, Project Management W2 Computer-Aided Design W3 Computer-Controlled Cutting W4 Electronics Production

I will use these skills in portions of my Final Project and document where this occurs.

Final Project

Keep It Simple

Rather than build a cardboard boat with electronics, build the electronics for Fab Academy, and then build the boat.

Accomplish One Idea

Build a device that senses temperature and provides an output.

Cancel Unreachables

I have not learned how to properly design a boat, but I do know how to design electronics. Put the boat in a drydock for a future spiral. Focus on electronics.

W5 Research¶

General to particular research, this should help students identify their topic, context and users.
Identify products that look similar to the concept of their project, for sure there are some parts that can contribute and you can direct better as an instructor.

Deliverables:¶

Final Project

Something Related to the Original Idea
Something Someone Has Done

Through collaboration with my Instructors we decided to make something that senses temperature and lights a RGB LED. This is related to my original idea and many people have done this.

Adrian Torres recommended this Weather Station Buoy for inspiration.

Rico Kanthatham inspired me with his Final Project.

Rico also gave my guidance to another student from his Fab Lab, Jun Kawahara

Through the Weather Station Buoy, I found additional inspiration for something more within my grasp with a smaller Smart Buoy.

In my wanderings I had an idea to change the Final Project completely; to an Automated Rat Trap. This was just another distraction (trap); although a good idea, it is not Simple.

W6 User Empathy¶

Create meaningful designs
What is the need? Will people be able to interact with your idea? Who finds this useful? Lab? Community? Country? World?
Human-centered Design

Deliverables¶

Assignment

This week my Instructors and I decided on a design that is meaningful, useful, and human-centered.

Reminder: Make a prototype of your project: Xiao + RGB LED (or led strips) + Temperature sensor. Connect in protoboard and program it.

Final Project

Meaningful Design

Smart Life Ring

Interact With Idea

Power Switch

Useful To Who

Water Sports

Human-centered Design

Life Ring for Water Rescue

Temperature Sensing to RGB LED Output Prototype¶

In an effort to focus my attention on the Final Project (so I can finish Fab Academy), my Remote Instructor, Pablo gave me an assignment to demonstrate the concept of giving an output (RGB LED) based on an input (temperature sensor). First, I needed to make a QuenTorres swd+uart adapter+hello board - XIAO RP2040 that I made in Electronics Production week to complete this assignment, so I ran out of time. However, I will still finish this assignment as I can.
I have a lot of learning material that I have wanted to use, so I will document the learning process here. My plan is to use the SunFounder Sensor Kit V2.0 to become familiar with the concept. I plan to use the RGB LED Module

And the Thermistor Module

The tutorial calls for an Arduino, but I plan to use the XIAO RP2040 since my Instructor recommended this. I also have a nice development board to help me do this Seeed Studio XIAO Starter Kit I will be using the development board tutorial by SeeedStudio. So here we go.
First, I had to download and install Arduino IDE since this is a newer computer than the one I have been developing with. Seeed Studio gave me the link in the tutorial. Next, I had to add Seeed Studio XIAO to Arduino IDE. Since I have many of their boards, I added all three links as they recommended. It took quite a while to download. All three boards were installed.
Next I connected the RP2040 that I used in the QuenTorres board and plugged it into the Seeed Studio XIAO Expansion Board. I followed the instructions, but still received an error as before. What appears to be the RP2040 mounting its uf2 drive showed that drive in the Port list, so I selected that drive and tried again. It worked that time and the Port then went back to COM8. This is the output:

Sketch uses 52260 bytes (2%) of program storage space. Maximum is 2093056 bytes.
Global variables use 10232 bytes (3%) of dynamic memory, leaving 251912 bytes for local variables. Maximum is 262144 bytes.
Resetting COM8
Converting to uf2, output size: 140288, start address: 0x2000
Scanning for RP2040 devices
Flashing F: (RPI-RP2)
Wrote 140288 bytes to F:/NEW.UF2

So what I thought was a coding error before, was a misunderstanding on my part. Another learning opportunity! Once I communicated with the board, it worked every time.
Now that I am on a roll, I will introduce you to the Seeed Studio XIAO Expansion Board. After I have a handle on the process and the programming, I hope to demonstrate with the QuenTorres.
This is the Seeed Studio XIAO Expansion Board.

This is the Seeed Studio XIAO Expansion Board pinout.

It is a very versatile board and I hope to make something similar in another spiral. For now, I will use it to detect temperature with the thermistor module.
As an interface between the modules, I will use a Grove Screw Terminal module

This enables me to adapt a 3-wire device to a 4-wire connector without fabricating the cable. I will do this later, but this is for prototyping. Here you have the setup of the Temperature Prototype.

This is the code I obtained from the Sensor Kit V2.0 for Arduino. It has been modified/commented out lines to exclude the use of a LCD display. I will only be using the serial monitor to see what is happening.

#include <Wire.h>
// #include <LiquidCrystal_I2C.h>
// initialize the library with the numbers of the interface pins
// LiquidCrystal_I2C lcd(0x27,16,2);  // set the LCD address to 0x27 for a 16 chars and 2 line display

#define analogPin  A0 //the thermistor attach to 
#define beta 3950 //the beta of the thermistor
#define resistance 10 //the value of the pull-up resistor


void setup()
{
  // set up the LCD's number of columns and rows: 
  // lcd.init();  //initialize the lcd
  // lcd.backlight();  //open the backlight 
  Serial.begin(9600);
}

void loop()
{
  long a =1023 - analogRead(analogPin);  //read thermistor value 
  Serial.print("Raw reading ");
  Serial.println(a); 
  //the calculating formula of temperature
  float tempC = beta /(log((1025.0 * 10 / a - 10) / 10) + beta / 298.0) - 273.0;
  float tempF = 1.8*tempC + 32.0;
  Serial.print("Centigrade ");
  Serial.println(tempC); 
  Serial.print("Fahrenheit ");
  Serial.println(tempF); 
  Serial.println("");
  delay(1000);

  // // Print a message of "Temp: "to the LCD.
  // lcd.setCursor(0, 0);// set the cursor to column 0, line 0
  // lcd.print("Temp: ");  // Print a message of "Temp: "to the LCD.
  // lcd.print(tempC); // Print a centigrade temperature to the LCD.
  // // Print the unit of the centigrade temperature to the LCD.
  // lcd.write(char(223));
  // lcd.print("C");//print the unit" ℃  "
  // lcd.setCursor(0, 1);// set the cursor to column 0, line 1
  // lcd.print("Fahr: ");
  // lcd.print(tempF);// Print a Fahrenheit temperature to the LCD.
  // lcd.write(char(223)); // Print the unit of the Fahrenheit temperature to the LCD.
  // lcd.print(" F");//print the unit"°F"
  // delay(200); //wait for 100 milliseconds
}

First I plug in the USB to the XIAO RP2040 I have mounted on the expansion board.

Now I communicate with the XIAO using the Arduino IDE and open the analogRes.ino file.

I Click Upload and the file is compiled and uploaded and you can see the output in the Serial Monitor

The Fahrenheit temperature is about 73 degrees in my Fab Lab and that is being displayed. When I touch the thermistor for about 30 seconds, you can see the temperature rises to almost 85 degrees.

This concludes the test of the thermistor, now on to the RGB module :)
Here you have the setup of the RGB Prototype.

This is the code I obtained from the Sensor Kit V2.0 for Arduino. It has been modified to use the XIAO RP2040 breakout pins on the expansion board: D7, D8, and D9. You can see the pinout in the image on the page above. I left the comments as is so you can see the difference between the pins used for the XIAO and the Arduino UNO.

/*************************************************************************
 * name:Rainbow LED
 * Function:you can see RGB LED flash red, green and blue first, and then change to red, orange, yellow, green, blue, indigo and purple.  
 * Note:because the RGB module is common anode,so when you want to turn on a color ,you need to set it as 0
 ********************************************************************/
const int redPin = D9;  // R petal on RGB LED module connected to digital pin 11 
const int greenPin = D8;  // G petal on RGB LED module connected to digital pin 10 
const int bluePin = D7;  // B petal on RGB LED module connected to digital pin 9 
/**************************************************************************/
void setup()
{ 
  pinMode(redPin, OUTPUT); // sets the redPin to be an output 
  pinMode(greenPin, OUTPUT); // sets the greenPin to be an output 
  pinMode(bluePin, OUTPUT); // sets the bluePin to be an output 
}    
/***************************************************************************/
void loop()  // run over and over again  
{    
  // Basic colors:  
  color(0,255,255); // turn the RGB LED red 
  delay(1000); // delay for 1 second  
  color(255,0,255); // turn the RGB LED green  
  delay(1000); // delay for 1 second  
  color(255,255,0); // turn the RGB LED blue  
  delay(1000); // delay for 1 second 
  // Example blended colors:  
  color(0,255,255); // turn the RGB LED red  
  delay(1000); // delay for 1 second  
  color(0,128,255); // turn the RGB LED orange  
  delay(1000); // delay for 1 second  
  color(0,0,255); // turn the RGB LED yellow  
  delay(1000); // delay for 1 second  
  color(255,0,255); // turn the RGB LED green  
  delay(1000); // delay for 1 second 
  color(255,255,0); // turn the RGB LED blue  
  delay(1000); // delay for 1 second
  color(255,0,0); // turn the RGB LED  indigo 
  delay(1000); // delay for 1 second
  color(128,255,0); // turn the RGB LED purple  
  delay(1000); // delay for 1 second
}     
/******************************************************/
void color (unsigned char red, unsigned char green, unsigned char blue)     // the color generating function  
{    
  analogWrite(redPin, red);   
  analogWrite(bluePin, blue); 
  analogWrite(greenPin, green); 
}
/******************************************************/

First I plug in the USB to the XIAO RP2040 I have mounted on the expansion board.

Now I communicate with the XIAO using the Arduino IDE and open the RGB.ino file.

I Click Upload and the file is compiled and uploaded and you can see the output in the Output panel.

Here you can see the prototype in action :) Pretty colors!

This concludes the test of the RGB LED, now on to the making them work together :)
This is an exciting time for me because I have never got this far with my Final Project. I ‘m so thankful that my Instructor pointed my in the right direction. Keep it simple and accomplish your goal in small steps. I have been told that before, but I never seem to get it and then I get overwhelmed by all the possible details and potential failures. I guess I get the proverbial Analysis Paralysis :) Well here it goes!
Seeing the temperature readout and the RGB LED change was the success I needed to push forward to the goal. I have some programming experience, so I have the confidence to move forward. I recently had a lesson from my Instructor during Global Open Time about programming and really needed that for this project.
I started with the analogRes.ino listed above, saved it as analogRes_RGB.ino and copied and pasted the parts I thought I needed to make this work. This is what I ended up with.

#include <Wire.h>
// #include <LiquidCrystal_I2C.h>
// initialize the library with the numbers of the interface pins
// LiquidCrystal_I2C lcd(0x27,16,2);  // set the LCD address to 0x27 for a 16 chars and 2 line display

#define analogPin  A0 //the thermistor attach to 
#define beta 3950 //the beta of the thermistor
#define resistance 10 //the value of the pull-up resistor

const int redPin = D9;  // R petal on RGB LED module connected to digital pin 9 
const int greenPin = D8;  // G petal on RGB LED module connected to digital pin 8 
const int bluePin = D7;  // B petal on RGB LED module connected to digital pin 7


void setup()
{
  // set up the LCD's number of columns and rows: 
  // lcd.init();  //initialize the lcd
  // lcd.backlight();  //open the backlight 
  Serial.begin(9600);
  pinMode(redPin, OUTPUT); // sets the redPin to be an output 
  pinMode(greenPin, OUTPUT); // sets the greenPin to be an output 
  pinMode(bluePin, OUTPUT); // sets the bluePin to be an output 
}

void loop()
{
  long a =1023 - analogRead(analogPin);  //read thermistor value 
  Serial.print("Raw reading ");
  Serial.println(a); 
  //the calculating formula of temperature
  float tempC = beta /(log((1025.0 * 10 / a - 10) / 10) + beta / 298.0) - 273.0;
  float tempF = 1.8*tempC + 32.0;
  Serial.print("Centigrade ");
  Serial.println(tempC); 
  Serial.print("Fahrenheit ");
  Serial.println(tempF); 
  Serial.println("");
  delay(1000); //I put this in the loop because it was going too fast to observe
  if (tempF < 79) { //I selected this temperature since the ambient temperature is about 73 degrees
    color(255,255,0); // turn the RGB LED blue  
    delay(1000); // delay for 1 second  
  }
  else if (tempF > 79 && tempF < 83) { //I selected these temperatures since they are in the middle
    color(255,0,255); // turn the RGB LED green  
    delay(1000); // delay for 1 second
  }
  else if (tempF > 83) { //I selected this temperature since it is below the temperature of my maximum 85 degrees
    color(0,255,255); // turn the RGB LED red 
    delay(1000); // delay for 1 second
  }

 color(255,255,0); // turn the RGB LED blue  
 delay(1000); // delay for 1 second 


  //   // Basic colors:  I left this in the program as a reference
  // color(0,255,255); // turn the RGB LED red 
  // delay(1000); // delay for 1 second  
  // color(255,0,255); // turn the RGB LED green  
  // delay(1000); // delay for 1 second  
  // color(255,255,0); // turn the RGB LED blue  
  // delay(1000); // delay for 1 second 

  // // Print a message of "Temp: "to the LCD. I left this here in case I wanted an LCD output
  // lcd.setCursor(0, 0);// set the cursor to column 0, line 0
  // lcd.print("Temp: ");  // Print a message of "Temp: "to the LCD.
  // lcd.print(tempC); // Print a centigrade temperature to the LCD.
  // // Print the unit of the centigrade temperature to the LCD.
  // lcd.write(char(223));
  // lcd.print("C");//print the unit" ℃  "
  // lcd.setCursor(0, 1);// set the cursor to column 0, line 1
  // lcd.print("Fahr: ");
  // lcd.print(tempF);// Print a Fahrenheit temperature to the LCD.
  // lcd.write(char(223)); // Print the unit of the Fahrenheit temperature to the LCD.
  // lcd.print(" F");//print the unit"°F"
  // delay(200); //wait for 100 milliseconds
}

/******************************************************/
void color (unsigned char red, unsigned char green, unsigned char blue)     // the color generating function  
{    
  analogWrite(redPin, red);   
  analogWrite(bluePin, blue); 
  analogWrite(greenPin, green); 
}
/******************************************************/

When I first ran the program, I had errors because I didn’t include “the color generating function”. At first I was confused because I thought it was a built-in function, but I was wrong. I looked at the RGB code again and found the function at the bottom. I also need to build intelligence into the code to make decisions (Just like Pablo said!) about the temperature and LEDs. At first, I thought the Case Stucture was the way to go, so I tried the structure and had a lot of trouble due to the floating point, so I used the IF/THEN/ELSE to keep it simple and easier to understand. The result is what you see above.
Now I will give it a try. Here you have the setup of the analogRES_RGB Prototype.

First I plug in the USB to the XIAO RP2040 I have mounted on the expansion board.

Now I communicate with the XIAO using the Arduino IDE and open the RGB.ino file.

I Click Upload and the file is compiled and uploaded and you can see the output in the Output panel.

Here you can see the output in the Serial Monitor.

Here you can see the prototype in action. I just stays red!

This concludes the initial test of the analogRes_RGB Prototype, now on to the troubleshooting :)
To troubleshoot, I will need a greater difference in temperature. I have 3 cups, too hot, just right, and too cold; left to right, respectively.

To troubleshoot, I have placed a bit of code to change color to blue for one second to see what was going on. That was only confusing because the blue LED would come on momentarily and switch back to red.
When I touch “too hot” temperature goes to 93-94 degrees, “just right” 79-80 degrees, and “too cold” is 56-55 degrees. I adjusted the setpoints as follows:

  if (tempF < 65) { //I selected this temperature since the coldest temperature was 56-55 degrees
    color(255,255,0); // turn the RGB LED blue  
    delay(1000); // delay for 1 second  
  }
  else if (tempF > 75 && tempF < 85) { //I selected these temperatures since they are in the middle
    color(255,0,255); // turn the RGB LED green  
    delay(1000); // delay for 1 second
  }
  else if (tempF > 85) { //I selected this temperature since it is below the temperature of hottest 93-94 degrees
    color(0,255,255); // turn the RGB LED red 
    delay(1000); // delay for 1 second

I expect the light to be blue when it is “too cold”, but it stays red. Further investigation shows that the Red LED wire should be plugged into the D9 pin and the Blue LED wire should be plugged into the D7 pin; they were backwards! I switched them and all was well :)
This shows the Serial Monitor when the LED turns Blue for “Too Cold”.

This shows the Serial Monitor when the LED turns Green for “Just Right”.

This shows the Serial Monitor when the LED turns Red for “Too Hot”.

This is the video showing the above results with the long waits in between cut out. Changed the video from 58 seconds to 27 seconds to reduce the size.

This concludes the troubleshooting and repairing of the analogRes_RGB Prototype, now on to making the PCB to house this concept :)

W7 Define the Scope and Target Audience¶

Bring your ideas back to earth, what is reachable?
This will help you guide them on what is possible based on the time they have to complete the project.
Study your context and target audience - For who are you designing?

Deliverables¶

Final Project

Reachable Idea

Since I have accomplished the assignment from my Instructors, this makes the idea reachable. We have dialed in (focused) on an attainable goal; sense temperature of water and light a RGB LED with a board I have designed.

Study Context and Audience

I studied the Smart Buoy and there is a lot packed into that little project. I plan to keep this simple ;) I will make a floating device that senses temperature and lights a RGB LED. My audience will have a need for safety while in the water. This Final Project will inform the swimmer and their audience about the safety of the swimmer.

W8 Problem Solving¶

Back to the 2 months left, What problem are you solving?It doesn’t have to solve worldwide problems. Innovativeideas usually solve a problem.
Will you be able to complete in 2 months? Phases!

Deliverables¶

Final Project

Problem Final Project Solves

There are many problems to be solved, but the key is to finish Fab Academy so I can get on with helping others succeed. To do this I must keep it simple and accomplish my goals one step at a time without being overwhelmed by the prospect of future steps. My Instructors brilliantly enforced this by making me focus on each step/goal on the way to completion.

Ultimately, I want to teach others to succeed in Fab Academy while accomplishing their dreams for the future, while incorporating boat-centered thinking and designing. Rather than starting with the boat, we should start with surviving in the water. If you can’t swim, you will drown. If you can swim, but you get tired, you will drown. We need a floatation device when we are sinking; whether we can swim or not. This Final Project solves that problem. Just like Global Open Time solved that problem during the COVID crisis.

Can you complete in 2 months?

My Instructors want me to make something that satisfies the requirements of the Final Project in 2 months so I will have time to improve it before I run out of time. That is such a wonderful idea; I give credit to my wise Instructors. Yes, I can complete in 2 months.

List Phases

Design thinking is a non-linear, iterative process that consists of 5 phases: 1. Empathize - what do your customers want when in and near the water? 2. Define - safety and enjoyment. 3. Ideate - how do we accomplish this? by providing safety while informing about the environment. 4. Prototype - sense the environment (temperature of water) and inform others (light a RGB LED) 5. Test - Make it and test it till it works.

You can carry out the stages in parallel, repeat them and circle back to a previous stage at any point in the process—you don’t have to follow them in order.

The 5 phases flow into each other from any direction, but they also inform in a non-linear and iterative process. In words, you Empathize with your users to help Define their needs, their problems, and your insights. You Ideate by challenging assumptions and create ideas for innovative solutions. Then you Prototype to start creating solutions; these prototypes provide opportunities to learn and spark new ideas. Be sure to Test the prototype solutions early and often to realize new ideas for the project while learning about your users and obtaining further insights that can redefine the problem.

So far, I have been doing this with the guidance of my Instructors. Now I know I can do this!

W9 Define Project and Sketching¶

Last chance to change aspects of your project.
Time Management
Create a solid structure to develop and create your final project idea.

Deliverables¶

Final Project

Possible Changes

The thought forming after consulting with my Instructors was to make a ball to throw in the water, sense temperature, and light a RGB LED based on temperature.

The problem was how to recover the device from the water. I decided on using a life ring with a safety lanyard to hold the device, so it could be recovered after use. This makes the project both informative and useful for water safety.

Time Management

I really want to understand and apply Supply Side Time Management. What better time to learn and use this principle of time management!? I have been using Trello for project management, but I need to tweak it so it demonstrates supply side time management.

Design Solid Structure of Idea

First, I need to design my own board that will accomplish the concept of this Final Project while keeping it simple ;) I will use the XIAO RP2040 on a board that provides power from an external LiPo battery, takes an input from a temperature sensor, and provide an output from a RGB LED.

Second, I need to design a sphere that will contain the electronics while keeping them safe from the water environment they will be in.

Finally, I will need to design a floatation device that keeps the sphere afloat while making it recoverable. So, here is a sketch of my Final Project at this point.

At the end of this iteration, I protoyped an Output Device for the Final Project. This allowed me to Ideate about the Final Project board design and the connectors I should use.

This pushed me forward to prototyping for the Input Device for the Final Project.

In order to make this happen, I will need to design a board to host the microcontroller and the connections necessary to receive the input and provide the appropriate output. Using the above list of materials, I have made a sketch of the initial concept of the board design.

This is an update of the Final Project Board prior to stuffing.

You can read more about this on the Electronics Design page.

In parallel with the conceptualizing of the board, I have also been thinking about the global structure of this project. I searched for an example of the globe I envisioned while I ordered a life ring to hold it in the center…I’m sure you noticed the life ring in the W6 User Empathy section ;) The life ring was in my mind’s eye, but making/designing the globe was a challenge. So I used the internet to search in Thingiverse.com for “sphere clear pla” because that was what I wanted and the material I intended to use. I got some really cool results, but the best was the Phillips Hue Globe Diffuser. THAT IS IT! I can work with that! So I researched a little bit. Turns out the author, ApatheticEnthusiasts (Robert Barton), did some research too. He summarized as, “This is a remix using parts from two things: Bottom and Top.” Eventually, I ended up with Fusion 360 design files from Abditus2 called the Sensor Sphere Box and the method of designing exactly what I need.

MAJOR NOTE: I did not design this globe from scratch. Let me reiterate, this design was obtained from Thingiverse.com and I was able to download the Fusion 360 files that Abditus2 provided back in December 04, 2018. I am able to manipulate the files and models to make the transformation I need. I did not use all of the models, just the plain sphere and the base unit. I will document the changes that I made so you can see what I have done.

This is the image of the design process, complete with the steps in Fusion 360.

This is the internal design that really fits for what I am trying to do.

So I brought the file into Fusion 360, isolated the parts I was interested in, added a torus to represent the life ring, and I am well on my way to saving this Final Project :) More to follow!

These are the drawings I made in Fusion 360. It took some time to figure out, but MAN, this is so cool!!!

This is a sketch of the Electronics Housing (Globe Base) and what I intended to do with the provided model in order to house the internals of the sensor globe. The 35mm x 22mm rectangle is for the Battery Holder and the long and narrow rectangle is for the FABCAT Board Holder. The inner circle is the NeoPixel Ring.

I have modified the Electronics Housing to be my own. I really appreciate the starting point from the Phillips Hue Globe Diffuser who pointed me to Abditus2. I couldn’t have done it alone! I made it simple; Battery Holder, FABCAT Board Holder, Temperature Sensor Mount, and NeoPixel Ring Mount. If necessary, I will make separate mounts for the Screw Terminal Mounts, but I think they will be fine secured to the Battery Holder with hot glue and hook and latch material.

I will put a video here so you can see how I made the transformation. In a nutshell, I removed the internals of Abditus2’s model and replaced them with my own to fit the internal components I will be using. I also modelled a NeoPixel Ring so I could figure out what height it had to be at in my new design. This was probably the coolest thing about it; I literally moved the parts around as if I was using my hands and it really helped with visualizing what I was trying to do. Lastly, I made a hole in the bottom for the temperature sensor and then extruded it so you could see what it would look like. Everything is to scale for the components I will be using; Battery, FABCAT Board, Temperature Sensor, and NeoPixel Ring. I measured them and used the dimensions is the designing process. Fab Academy has really strengthened me in the 2D and 3D design area because I have to do this to realize the full potential of digital fabrication. I’m getting there, but slower than most. Accomplishing what I am about to show you was challenging for me, but I feel like I have accomplished a major milestone in my modelling journey. I hope this helps some students in the future. It was tricky to select every surface before deleting things; sometimes the whole part disappeared and I had to rewind. I hope you enjoy the show ;)

My intention is to add to this Final Project in spirals with the time I have, so it will need to be a flexible/temporary design. Having a threaded globe allows me to make changes while making the design as simple as possible. My plan is to secure the components in the Electronics Housing with hot glue as well as hook and latch material; this allows for changing things as the project develops in spirals without having to reprint the Electronic Housing (Globe Base). This will allow me to fasten additional boards to the Battery Holder on the outside as well as fasten the battery to the inside of the Battery Holder. This design will also allow recharging the battery without having potential leaks through external connectors; in other words, easily remove the battery for recharging.

W10 WBS, Assignment Integration, Risk Analysis and BoM¶

Deliverables¶

Final Project

WBS- Work Breakdown Structure (Activities, timeframes, needs, wants, haves)

To make the Work Breakdown Structure (WBS) I used a tool I thought was useful in the past, but never really got to explore it. I have an account with Lucid so I dusted this app off and went to work. This would be a good entry for the Project Management documentation. I will have to add that in another spiral. (Note To Self: Add this to Week1)

The the app has many templates to use and WBS was one of them, so I used the template and added my own information and this is what I have.

The timeframe is shown at the end of this section. The needs: I need to finish; to do that I will sense temperature and light a neopixel ring. I als want to sense whether there is leakage in the sensor globe and I want a power switch to turn the sensor globe on and off. I have everything to do these things, but I have to finish. Therefore, I will keep it simple. If I have time, I will do more of my wants, but for now…keep it simple.

Everything is important but focus on what you will need- What assignments for your final project?

I took the CSV file generated by the WBS and started modifying it. I will need to update the graphic version because I saw a lot of holes and assignments that could be incorporated into the Final Project. I will try to show what I did.

And this table shows the assingment integration.

What happens is somethings goes wrong?

Believe me, I have had things go wrong! To be fair, you cannot plan for the unexpected; however, if you know the unexpected will occur, you won’t be so devastated that you just give up when things go wrong. I have not given up and I will continue to adapt and overcome by the Grace of God. It is His strength that keeps me going when the going gets rough. Just keep swimming, swimming, swimming… :)

Bill of Materials - hand in to your local instructors

This is the BoM for the Final Project. Just a word of warning: If you have everything you need in a Fab Lab, this is a realistic number. If you must make a Fab Lab to do this project, like I did, the Bill will be far greater. As I read just this week, “No project was ever completed on time and within budget.” I will try to find the source, but, in my experience, this is a true saying. This statement came from the Risk Analysis and Contingency Plan Guidelines by Sunil Sharma at PMI.org Sharma goes on to say, “Identifying risks associated with a project and mitigating them is a crucial activity of project planning. Managers need to not only analyze project risks, but also must develop contingency plans to address those risks.” I intend to use these guidelines to better understand and mitigate the risks associate with this Final Project.

So when will the WBS be completed? I hope in less than 2 months, but no later than June 5, 2024. This is my schedule right now.

This is a more detailed WBS with the iterations for Plan, Design, Make, and Debug status. I will update this as progress occurs.

W11 Acquire Materials¶

Deliverables¶

Final Project

Fab Labs should be provided with all possible materials for students to create their final project

My personal Fab Lab has been in the process of being fully stocked with the inventory required to successfully complete the Fab Academy. It has been a great undertaking as an individual without external funding, but I will say it is doable if managed properly.

BoM will help for this process to be completed on time

The BoM was documented in the W10 section and the materials are on hand in my personal Fab Lab.

This is the time!

This is an exciting time! I hope you enjoy the ride :) Here we go!

This is the WBS status as of Week 11. Slightly ahead of schedule!

W12-W13 Pre-Production¶

Deliverables¶

Final Project

Based on their schedule students can start producing some of the parts of their project and test the concepts you had for it

We are well into the second half of Fab Academy and I feel confident about the whole process of learning in this environment. The two most difficult parts for me has been design and documentation; I am more confident in both of these areas and I can see the finish line.

This cycle I have been blessed with wonderful Instructors, all of the required inventory, and plenty of time to explore this learning space.

As you can see, I have already begun making parts of my project and testing the concepts I have incorporated into the Final Project. The heart of the project is the FABCAT board and I am confident that it can perform as imagined. I have also completed most of the designs for the rest of the parts and will be making them soon.

It’s About Continuous Testing & Managing wisely your resources (time, materials, effort)

As you have seen in the previous sections, I have been diligently testing the concepts of the Final Project while managing the time, materials, and effort required to be successful. I will continue to be disciplined in these areas with the guidance of my Instructors who have been so helpful.

With the Design for the Electronics Holder complete, it is time to Make. This will be a Pre-Production/Prototype run to verify that the Design was correct and Debug if necessary.

The 3D printing required exporting the model designed in Fusion 360 to a STL format, then importing it into PrusaSlicer. Since this has been practiced many times before, I was fairly comfortable with the process. I still learned a bit more. When I imported the STL into PrusaSlicer, the model was on its side.

I used the Rotate tool and the widget to rotate the model as close to 90 degrees as I could get it. There is not a method to type the value in, so using the mouse was the best I could do. I got it to 90.03 and thought that was good enough.

The small difference caused the model to be slightly off the plane and made a separation in the base. This was puzzling to me, but I went with it and figured it would work out. I exported the g-code and tried to print. This is what the bottom looked like.

And this is the top.

The edge lifted up so much that it caused the first crash I have had on my Prusa 3D printer. I stopped the print and went back to the design. The design was still the same and I changed the orientation of one of the models thinking that was the problem. It still came into PrusaSlicer on its side. But this time I decided to use “Place on face”.

As soon as I clicked on the base face, it rotated to the perfect position.

I exported the model with the same settings, but this time I added supports everywhere. (Just to be safe :)

The print job took 11.5 hours, but it was worth the wait.

I wanted to make sure the prototype had the proper dimensions.

Perfect fit! Now for the post-processing :)

The next print job was the globe. I imported it the same as the Electronics Housing. I oriented it in the upward position and chose supports everywhere. I exported the g-code and it said it would take 24.5 hours. I started it Friday night and on Saturday morning I decided to listen to it while I probed analog and digital devices. What an enjoyable experience :) This is what I found in the morning.

A little bit later. Looking pretty cool!

Almost there!

Would you look at that!

Post-processing was a very rewarding experience. Here is the globe parted from the 3D printer.

This after I cut around the edges.

I pulled the support out of the globe and here is a good picture.

Perfect fit!

While I was waiting on the print job, I worked on designing the Power Supply Module… This seemed like a simple task since I had designed more complex boards. To be safe, I did some research on the Internet. I found some good help from LM1117 Linear Voltage Regulator by AaronPrice. I didn’t need a variable power supply, but this was a nice Instructable. Since there were so few parts, I decided to design in the Fusion 360 app. This was no small feat, but it all turned out well. This is my schematic.

This is my board.

I used my documentation from Electronics Design to refresh my memory.

First, I save the Fusion 360 project as an Eagle 9.x format as I described in Electronics Design and exported the trace image, drills, and border for GIMP. After cropping them to the proper size, this is what I sent to mods.

The trace image.

Drill holes for the through-hole screw terminals.

And border to cut out the board.

I used mods old index to generate the G-code from mill 2D PCB png.

The trace image.

Drill holes for the through-hole screw terminals.

And border to cut out the board.

Now I need to mill the Power Supply Module board. Thankfully, I already had my FR-1 mounted from my last job. I pressed down on the material to make the tape stick again and I taped around the edges for extra protection. I only had 37mm wide material left and the board required just that. I wanted to run the traces first to be sure I had enough room.

First, I raised the endmill and zeroed Z to cut air and figure out if it would fit. It was just big enough :)

Then I drilled the holes using this g-code.

Again, I cut air, and I am so glad I did. When I designed the board I used vias to make the holes. I had never designed through-holes, so this was a first. I’m glad I was cautious. Although they were in the right place, they were way too big. My solution was to operate the CNC using the Candle interface to position the endmill (using the g-code generated image). I changed the endmill to 1mm since the posts on the screw terminals were 0.95mm and drilled each hole to a depth of 1.8mm at 0.1mm increments. Kind of a hack, but it worked beautifully. The posts were 5mm apart and it was so cool to use the machine with precision.

This is the border for cutting out the board.

I ran the jog, but I was a little nervous about the tape holding, so I kept my finger on the mouse to abort if necessary. I’m glad I did, because the board popped up a little on the last round and I aborted. It made it successfully.

I cleaned the board to prepare it for stuffing. The traces were real thin, so I was nervous, but they all survived.

This is the electronics side stuffed. The capacitors were a surprise. I thought I was using 1206, but the pads were huge and too far apart. I had selected the wrong capacitor footprint in Fusion 360. It was from the Fab inventory, but not the one I wanted. All I had in this size footprint was a 100uF electrolytic capacitor. I did some research and found someone who used a 100uF electrolytic capacitor for a LM1117 circuit and it worked just fine, so I did the same. I’ll tell you what; these are not fun to solder. The base is plastic and it melts when touched with the solder iron. A very delicate process! But I got it done; although it was a little messy :)

Then I soldered the screw terminals in the through-holes. I used clear tape to hold them in place while I soldered the and it worked fine.

I cleaned up the board with cotton swabs and alcohol, then brushed off the cotton fibers that remained.

Now for testing! It was getting late, but I just had to see this board working. It was the first of its kind for me and I was pretty excited. I should have taken pictures, but I was on an adventure of discovery. I connected my MDP-P905 digital power supply to the input and connected my multimeter to the output. I set the input to the 7.4V setting for the battery I planned to use and set the current to 1A since that was the fuse I plan to use. When I applied power, the voltage input was good and the current settled at 35mA. However the output was fluctuating and various voltages up to 8V and thereabouts. I had a faulty circuit somewhere. I used my multimeter to trace from the input to the output and found the faulty trace that was the ground wire to the input capacitor. This is after I fixed it, but you can see the missing piece of the trace.

Long story short, I thought it vaporized, but it was done by me when I cleaned the board. After bridging the solder and testing, the power supply module worked and powered up my FABCAT board.

This is the setup to test the power supply module. You can see the output on the multimeter.

This shows the output of the digital power supply.

This is a video of powering up the FABCAT board with the digital power supply.

Now I have a power supply to prototype the Final Project :)

The next step is to install the hardware in Electronics Housing. The simplest way I could think of and still look acceptable was to use hook and loop material with adhesive on one side. Here’s the sketch and where the material will go.

Hook applied.

Loop applied.

FABCAT Board attached.

Power supply loop.

Power supply attached.

Here’s a few shots after assembly.

Now that the hardware is installed, I need to apply battery power and test the FABCAT board operating on the onboard battery. This is an image of the Electronics Housing operating on battery power.

The next step is to program the FABCAT using the USB-C connection. To do this I must disconnect the battery. While I do this, I will add some hook and loop inside the Battery Holder to hold the battery in place during operation.

This will hold the battery in place.

With the battery secured and disconnected, I will plug in the USB-C connector to the FABCAT board to connect to the computer.

Then I turn on the USB hub to connect to the computer.

To follow the order of testing from before, I will upload the temperature sensor program using Thonny.

# Rui Santos & Sara Santos - Random Nerd Tutorials
# Complete project details at https://RandomNerdTutorials.com/raspberry-pi-pico-w-micropython-ebook/
# Modified by Jim Hart 4/1/2024

import machine, onewire, ds18x20, time

# Pin configuration for DS18B20 temperature sensor
ds_pin = machine.Pin(29)

# Create DS18X20 object using OneWire protocol with specified pin
ds_sensor = ds18x20.DS18X20(onewire.OneWire(ds_pin))

def celsius_to_fahrenheit(temp_celsius):
    # Convert temperature from Celsius to Fahrenheit
    temp_fahrenheit = temp_celsius * (9/5) + 32 
    return temp_fahrenheit

# Scan for DS18B20 sensors and print their ROM addresses
roms = ds_sensor.scan()
print('Found DS devices: ', roms)

while True:
    # Initiate temperature conversion for all sensors
    ds_sensor.convert_temp()
    time.sleep_ms(750)  # Wait for the conversion to complete (750 ms is recommended)

    for rom in roms:
        print(rom)

        # Read temperature in Celsius from the sensor
        temp_c = ds_sensor.read_temp(rom)

        # Convert Celsius temperature to Fahrenheit
        temp_f = celsius_to_fahrenheit(temp_c)

        # Print the temperature readings
        print('temperature (ºC):', "{:.2f}".format(temp_c))
        print('temperature (ºF):', "{:.2f}".format(temp_f))
        print()

    time.sleep(5)  # Wait for 5 seconds before taking readings again

I am holding the buoy by the temperature sensor.

This screenshot shows the temperature rising.

This concludes the temperature test of the Smart Ring Buoy.

To contnue the order of testing from before, I will upload a neopixel program using Thonny. This neopixel ring program was written for the NeoPixel WS2812B RGB LED with Raspberry Pi Pico (MicroPython). Since I am using a 24 LED Neopixel Ring and the XIAO RP2040, I will make the changes necessary and document the changes.

# Original Author https://electrocredible.com/neopixel-micropython-raspberry-pi-pico-ws2812b/
# Modified by Jim Hart on April 16, 2024

import neopixel
from machine import Pin
import time

ws_pin = 6 # This is the pin I have the signal line attached to
led_num = 24 # This is the number of LEDs on my NeoPixel Ring
BRIGHTNESS = 0.2  # Adjust the brightness (0.0 - 1.0)

neoRing = neopixel.NeoPixel(Pin(ws_pin), led_num)

def set_brightness(color):
    r, g, b = color
    r = int(r * BRIGHTNESS)
    g = int(g * BRIGHTNESS)
    b = int(b * BRIGHTNESS)
    return (r, g, b)

def loop():
    # Display red
    color = (255, 0, 0)  # Red color
    color = set_brightness(color)
    neoRing.fill(color)
    neoRing.write()
    time.sleep(1)

    # Display green
    color = (0, 255, 0)  # Green color
    color = set_brightness(color)
    neoRing.fill(color)
    neoRing.write()
    time.sleep(1)

    # Display blue
    color = (0, 0, 255)  # Blue color
    color = set_brightness(color)
    neoRing.fill(color)
    neoRing.write()
    time.sleep(1)

while True:
    loop()

This is the Thonny IDE.

You can see the NeoPixel Ring operating in Red.

You can see the NeoPixel Ring operating in Green on Battery Power.

You can see the NeoPixel Ring operating in Blue on Battery Power with the Globe on.

This concludes the test of the NeoPixel Ring in the Smart Ring Buoy, now on to making them work together :)

This is the WBS status going into Week 12. Pre-Production is well on its way!

Since this is also Molding and Casting week, I will work on 1.2.8 Epoxy Coating while I continue with testing the programming and electronics.

My first task is to print a prototype (50% scale) of the Globe and Electronics Housing. Note: I am printing the Globe upside down per my Instructor Pablo’s recommendation. At 50% scale it will only take 3.1 hours to print. This will allow me to test the Marine Epoxy Resin that I intend to coat the Globe and Electronics Housing with.

While I wait for the print job, I will work on combining the temperature sensing and NeoPixel Ring output programming.

I combined the two programs above into a single program. I also used the code from the aduino program I used to test the NeoPixel Ring previously.

# Rui Santos & Sara Santos - Random Nerd Tutorials
# Complete project details at https://RandomNerdTutorials.com/raspberry-pi-pico-w-micropython-ebook/
# Modified by Jim Hart 4/1/2024
# Original Author https://electrocredible.com/neopixel-micropython-raspberry-pi-pico-ws2812b/
# Modified by Jim Hart on April 17, 2024

import machine, onewire, ds18x20, time, neopixel  # Added neopixel from electrocredible
from machine import Pin


# Pin configuration for DS18B20 temperature sensor
ds_pin = machine.Pin(29)
ws_pin = 6 # This is the pin I have the signal line attached to
led_num = 24 # This is the number of LEDs on my NeoPixel Ring
BRIGHTNESS = 0.2  # Adjust the brightness (0.0 - 1.0)

# Create DS18X20 object using OneWire protocol with specified pin
ds_sensor = ds18x20.DS18X20(onewire.OneWire(ds_pin))

# Create an instance of the NeoPixel class called neoRing
neoRing = neopixel.NeoPixel(Pin(ws_pin), led_num)

def celsius_to_fahrenheit(temp_celsius):
    # Convert temperature from Celsius to Fahrenheit
    temp_fahrenheit = temp_celsius * (9/5) + 32 
    return temp_fahrenheit

def set_brightness(color):
    r, g, b = color
    r = int(r * BRIGHTNESS)
    g = int(g * BRIGHTNESS)
    b = int(b * BRIGHTNESS)
    return (r, g, b)

# Scan for DS18B20 sensors and print their ROM addresses
roms = ds_sensor.scan()
print('Found DS devices: ', roms)

while True:
    # Initiate temperature conversion for all sensors
    ds_sensor.convert_temp()
    time.sleep_ms(750)  # Wait for the conversion to complete (750 ms is recommended)

    for rom in roms:
        print(rom)

        # Read temperature in Celsius from the sensor
        tempC = ds_sensor.read_temp(rom)

        # Convert Celsius temperature to Fahrenheit
        tempF = celsius_to_fahrenheit(tempC)

        # Print the temperature readings
        print('temperature (ºC):', "{:.2f}".format(tempC))
        print('temperature (ºF):', "{:.2f}".format(tempF))
        print()

    time.sleep(5)  # Wait for 5 seconds before taking readings again
    # delay(1000);   # I put this in the loop because it was going too fast to observe
    if (tempF < 65): #{ # I selected this temperature since the ambient temperature is about 73 degrees
    # color(255,255,0); // turn the RGB LED blue  
    # delay(1000); // delay for 1 second 
    # Display blue
        color = (0, 0, 255)  # Blue color
        color = set_brightness(color)
        neoRing.fill(color)
        neoRing.write()
        time.sleep(1)    
    #}
    elif (tempF > 75 and tempF < 85): #{ # I selected these temperatures since they are in the middle
    # color(255,0,255); // turn the RGB LED green  
    # delay(1000); // delay for 1 second
    # Display green
        color = (0, 255, 0)  # Green color
        color = set_brightness(color)
        neoRing.fill(color)
        neoRing.write()
        time.sleep(1)
    #}
    elif (tempF > 85): #{ # I selected this temperature since it is below the temperature of my maximum 85 degrees
    # color(0,255,255); // turn the RGB LED red 
    # delay(1000); // delay for 1 second
    # Display red
        color = (255, 0, 0)  # Red color
        color = set_brightness(color)
        neoRing.fill(color)
        neoRing.write()
        time.sleep(1)
    #}

I have not programmed in MicroPython much, so I had a few things to learn. The comments use a “#” rather than a “//”. The IF-THEN-ELSE is now ELIF and a “:” after the “(expression) rather than braces. MicroPython is also picky about indentation. After several iterations I had it working in the form above :)

The program must be saved as main.py to the RP2040 in order for it to run on powerup.

Now I need to test the input-processing-output. I don’t have remote read capability yet. That will be another spiral. However, I can connect to the USB-C connection on the RP2040 and watch the serial monitor output during operation.

This is the serial output while in hot water.

This is the NeoPixel Ring properly displaying red.

This is the serial output while in just right water.

This is the NeoPixel Ring properly displaying green.

This is the serial output while in cold water.

This is the NeoPixel Ring properly displaying blue.

Now I will unplug the USB-C cable, connect the battery, screw on the globe, and test the Smart Buoy.

The other test I need to do is check the power usage of the Smart Buoy while it is operating at the battery voltage. This is my setup with the digital power supply connected to the power connector.