Project Development

For this final entry, I will be going through the project development process of our chemical product, where we show our group's planning and execution stages, the problems faced and how we solved them.

The format of this entry will be done using a project development provided. It is as follows.

1. Our Team Chemical Device

Our team's chosen chemical device is UV Handphone Sterilization Box. The reason we chose this product is, in view of the recent (not exactly) coronavirus, we found out that our handphone's may harbor more germs and bacteria then we imagine. It is not a shocker to say that our handphones can be one of the leading reasons to how the coronavirus spreads, since we are constantly in contact with it.

Hence, we wanted to create a device that will allow us to sanitise our phones as efficiently as we wash our hands.

Using water and soap is definitely not a feasible way to clean our handphones as the water will damage the electrical parts, and using a alcohol swab may leaving wet stains on the phone surface. Thus, we decided to incorporate the use of UV rays to kills all the germ and bacteria on our phone, without causing damage or watermarks. A UV light sanitiser also takes less than 1 minute, 3o seconds even, to thoroughly clean the phone, letting it us it again quickly!

This is the FINALISED sketch of our product:

2. Team Planning, Allocation and Execution

Our team members are Jia Min, who is the Chief Financial Officer (CFO). She found the most optimal yet inexpensive items for our prototype so that we will stay under budget ($100). She was also responsible for the design, using Fusion 360, and assembling of the prototype.

Aqilah is the Chief Operating Officer, who was responsible for soldering and assembling the weight sensor, alongside the coding using the Arduino.

I (Ji Hyun) was appointed the CEO, where I made sure everybody stayed on tracked within our time frame. Not only that, I worked together with Aqilah to ensure that the weight sensor performs as it should.

Two people were involved in the coding and assembling of the weight sensor as we were dealing with something we have not used before. We were unfamiliar with the mechanism of the weight sensor, how it works and how it connects to the Arduino. Thus, deciding that one head is better than one, two people dealt with the coding and assembling, while one person designed the product. But don't get us wrong, we all chipped in to discuss the sketch and helped one another when required, no matter what specific task we were allocated too.

This is the our Gantt Chart which shows the timeframe of each task spent to achieve the final product.

The Gantt Chart above is our planned time frame, but obviously there were changes a long the way, so the Gantt Chart attached below is the ACTUAL one.

And this is the our finalised Bill of Material (BOM),

Our BOM has changed a lot from our initial design as we went along the project, we made many improvements and also realised many flaws. Thus, our sketch went through a numerous of changes, and according to that, the materials we required also changed.

3. Design and Build Process

Part 1. Design and 3D Printing of the base and hinged lid

(Done by Jia Min: https://jiamin20.wixsite.com/cp5070-2b07-2-jiamin/post/project-development-%D9%A9-%E1%B5%95-%E0%B9%91 )

For the 3D printing, we decided on printing only the base and the hinged lid to save time. We used iPhone 13 Pro Max as a size guide since it is one of the bigger phones in the market and we wanted our product to cater to as many handphone models as possible, regardless of the size of the phone. Image attached is the base and hinged lid designed on Fusion 360 and the parametric used.

And the Cura setting were at 0.3 mm layer height and 150 mm/s for the print speed. Support was included for both the designs as well.

This video is our hinged lid being printed.

Initially, after the first trial of the hinged lid printing, while removing the support, we accidentally cut through the hinge, which caused it to break. So, we went for a second run, and even on the second run, the hinge broke apart. This time not because excessive strength was used, but because the layer connecting the lid and the hinge was too thin. Attached is the picture of the perfectly cut out base and the two failed hinged lids.

Due to time constrain, we had insufficient time to go for a third run of 3D printing. Thus, we thought of insert a rod along the hinge, so that it will be better connected. However, since drilling a hole, long enough for a rod to inserted was impossible for our group, Jia Min used hot glue gun in between the broken parts for increased friction. And this method worked! Below is the video of the working hinged lid.

Further details of the design and build process of the 3D printing will be shown in Jia Min's blog, which can be accessed clicking on the link provided on top.

Part 2. Design and Laser Cutting of the outer walls of the box

(Done by Jia Min: https://jiamin20.wixsite.com/cp5070-2b07-2-jiamin/post/project-development-%D9%A9-%E1%B5%95-%E0%B9%91 )

Initially, we had no intentions of laser cutting any parts of our box. We were going to cover the exterior of the box with a corrugated cupboard and wrap it with PVC sheet. However, we soon realised that this was not a good method as not only was the PVC sheet too flimsy, the corrugated board was translucent, not giving us the opaque look we wanted. Therefore, Jia Min went on to hurriedly create rectangular walls on Fusion 360 that would enable us to cover the exterior of the box entirely with the opaque acrylic.

The settings used in CorelDraw are RED for VECTOR (Acrylic 3mm) and GREEN for ENGRAVE since Jia Min included a logo of our group on one of the rectangles (Acrylic 300 dpi). Both Auto-focus and Air-assist ON.

This is Jia Min setting up for laser cutting at the FabLab.

Further details of the design and build process of the laser cutting will be shown in Jia Min's blog, which can be accessed clicking on the link provided on top.

Part 3. Soldering and Connection to Arduino

(Done by Ji Hyun and Aqilah: https://aqilahqcheng0320.wixsite.com/cp5070-2b07gp2aqilah/about-5-1)

The weight sensor we used is a 5kg load cell, which is an electronic sensor for measuring weight and force. Essentially, it is an transducer that translates force into measurable electrical output. It will read weights when a force is applied to it and return back to its original position when removed. However, the output signal of this load cell is in millivolts, so we need an amplifier to convert the signal to a level that we can later transform it into digital signal and process it. For this purpose, the HX711 Amplifier sensor was used. It includes a HX711 chip with analog-to-digital conversion capabilities in 24-bit-accuracy. The HX711 module amplifies the low-voltage output of the load cell and send it to the Arduino so that the Arduino can calculate weight from this data.

To connect the load cell to the amplifier sensor we had to connect the red wire to E+, black wire to E-,

green wire to A- and the white wire to A+. To do so, we soldered the wires on the load cell to a female-to-male jumper wire and connected that to the HX711 amplifier. This helped to reduce the effort taken for the connection between the two since we have more surface area to work with during the interfacing. We received help from the TEs to guide us through the soldering, since we had never done it before. This was our first time soldering anything, so it was a very exciting experience for me. Below are pictures of Aqilah and I soldering.

We had to solder the load cell to the amplifier twice as initially, the female-to-male jumper wires used were faulty, causing our load cell to interpret no readings.

Once the connection from the load cell to the amplifier was complete, we went on to do the connection between the amplifier and the Arduino. This was much more smooth-sailing then the previous connection all we had to do was use more female-to-male jumper wires to connect GND to GND, VCC to 5V, DT to Pin 3 and SCK to Pin 2. Once that was complete, we achieved the whole connection of the weight sensor.

The weight sensor was not the only item that had to be soldered. The fairy light, which acts as our UV light, had to be soldered as well since it did not a connection port to the Arduino. It actually came with a battery and battery holder, so we had to first disassemble all that to be just left with the wire of fairy lights. Then we soldered the two exposed wire ends to a male-to-male jumper wires which can then be connected to Arduino. One wire goes to GND and the other goes to Pin 13.

The pictures are the final setup of the whole connection system.

Aqilah's perspective on the soldering and connection process can be found on her blog, which is linked above.

Part 4. Arduino Programming

(Done by Ji Hyun and Aqilah: https://aqilahqcheng0320.wixsite.com/cp5070-2b07gp2aqilah/about-5-1)

For the Arduino programming, we had to first and foremost download the HX711 library and include that into our Arduino, so that the it will be able to reading the weights. The source we used to download the code and make reference to the codes comes from this website: https://www.instructables.com/Tutorial-How-to-Calibrate-and-Interface-Load-Cell-/#discuss

Once the adding of the HX711 library is done, we go on to calibrate the load cell. Calibration of the load cell is needed so that each it is used, it will be calibrated with a known mass, ensuring best approximation mass of the unknown mass, increasing accuracy. Using the source code from the same website given, we calibrated the load cell.

This is the calibration code:

#include "HX711.h"

HX711 scale(2,3);

float calibration_factor = -14; // this calibration factor is adjusted according to my load cell

float units;

float ounces;

void setup (){

Serial.begin(9600);

Serial.println("HX711 calibration sketch");

Serial.println("Remove all weight from scale");

Serial.println("After readings begin, place known weight on scale");

Serial.println("Press + or a to increase calibration factor");

Serial.println("Press - or z to decrease calibration factor");

scale.set_scale();

scale.tare(); //Reset the scale to 0

long zero_factor = scale.read_average(); //Get a baseline reading

Serial.print("Zero factor: "); //This can be used to remove the need to tare the scale. Useful in permanent scale projects.

Serial.println(zero_factor);

}

void loop() {

scale.set_scale(calibration_factor); //Adjust to this calibration factor

Serial.print("Reading: ");

units = scale.get_units(), 10;

if (units < 0)

{

units = 0.00;

}

ounces = units * 0.035274;

Serial.print(units);

Serial.print(" grams");

Serial.print(" calibration_factor: ");

Serial.print(calibration_factor);

Serial.println();

if(Serial.available())

{

char temp = Serial.read();

if(temp == '+' || temp == 'a')

calibration_factor += 1;

else if(temp == '-' || temp == 'z')

calibration_factor -= 1;

}

}

Then, we just upload this code to Arduino, and click on the top right-hand icon to view the serial monitor. Once it starts reading 0.0g, add a known weight, for this case we used an iPhone 13 Max Pro which is 250g, and calibrate the load cell by pressing 'a' to increase and 'z' to decrease the calibration factor, until we reach the mass of the known weight. For us, a calibration factor of -40 was sufficient.

With the calibration factor obtained, we go on to open the actual code for the HX711, which is also provided, and change the calibration factor and the output pin number accordingly. With that, we can go onto to uploading the code to the Arduino again. Place a weight on the load cell, open up the serial monitor, and we will observe that there are readings for the for the weight displayed.

This is the single HX711 plus weight code:

#include "HX711.h"

HX711 scale(2, 3); //HX711 scale(2, 3);

float calibration_factor = -40;

float units;

float ounces;

void setup()

{

Serial.begin(9600);

Serial.println("HX711 weighing");

scale.set_scale(calibration_factor);

scale.tare();

Serial.println("Readings:");

delay(3000);

}

}

void loop()

{

Serial.print("Reading:"); units = scale.get_units(),10;

if (units < 0)

{

units = 0.00;

}

ounces = units * 0.035274;

Serial.print(units);

Serial.println(" grams");

delay(1000);

}

Now that we had the weight sensor all working, we had to add in the code for the LED light. This was easy to code as we had already learnt about the blink and fade feature during our lesson on Arduino. The only problem was, we did not know how to stop the loop. If we put a delay after the LOW output, it will just turn on again after the delayed time and just ending the code after the LOW output did not work as well. Thus, after a few searches on the internet, I found out that out an exit(0) commands the loop to pause. This is presumably because the exit(0) acts as a pathway for the loop to exit the program after one round. The code for the LED light looks like this:

void setup(){

pinMode(13,OUTPUT);

}

void loop(){

digitalWrite(13,HIGH);

delay(20000);

digitalWrite(13,LOW);

exit(0);

}

We also wanted to add in music at the end of the whole cycle to indicate the completion of the sanitisation. The code we used was the same code we used for toneMelody during our Arduino lesson as well.

#include "pitches.h"

// notes in the melody:

int melody[] = {

NOTE_C4, NOTE_G3, NOTE_G3, NOTE_A3, NOTE_G3, 0, NOTE_B3, NOTE_C4

};

// note durations: 4 = quarter note, 8 = eighth note, etc.:

int noteDurations[] = {

8, 8, 8, 8, 8, 8, 8, 8

};

void setup() {

//start serial connection

Serial.begin(9600);

//configure pin 2 as an input and enable the internal pull-up resistor

pinMode(2, INPUT_PULLUP);

pinMode(13, OUTPUT);

}

void loop() {

//read the pushbutton value into a variable

int sensorVal = digitalRead(2);

//print out the value of the pushbutton

Serial.println(sensorVal);

// Keep in mind the pull-up means the pushbutton's logic is inverted. It goes

// HIGH when it's open, and LOW when it's pressed. Turn on pin 13 when the

// button's pressed, and off when it's not:

if (sensorVal == HIGH) {

} else {

for (int thisNote = 0; thisNote < 8; thisNote++) {

// to calculate the note duration, take one second divided by the note type.

//e.g. quarter note = 1000 / 4, eighth note = 1000/8, etc.

int noteDuration = 1000 / noteDurations[thisNote];

tone(8, melody[thisNote], noteDuration);

// to distinguish the notes, set a minimum time between them.

// the note's duration + 30% seems to work well:

int pauseBetweenNotes = noteDuration * 1.30;

delay(pauseBetweenNotes);

// stop the tone playing:

noTone(8);

}

}

}

Finally, with all the individual codes ready, we just had to merge them into one to get the code working as we wanted it to. This part gave us a little bit of a problem as well since we were unfamiliar with merging codes. But with help received from our friends, searching the internet for sample codes and just us playing around with the code, led us to successfully merging the codes well together. Below is our final code:

#include "HX711.h"

HX711 scale(3, 2); //HX711 scale(3, 2);

float calibration_factor = -31000;

float units;

float ounces;

#include "pitches.h"

// notes in the melody:

int melody[] = {

NOTE_C4,NOTE_CS3,NOTE_G3,NOTE_B2,NOTE_CS3,0,NOTE_B3,NOTE_C4

};

// note durations: 4 = quarter note, 8 = eighth note, etc.:

int noteDurations[] = {

8, 8, 8, 8, 8, 8, 8, 8

};

void setup()

{

Serial.begin(9600);

Serial.println("HX711 weighing");

scale.set_scale(calibration_factor);

scale.tare();

Serial.println("Readings:");

delay(3000);

pinMode(13, OUTPUT);

}

void loop()

{

Serial.print("Reading:"); units = scale.get_units(),10;

if (units < 0)

{

units = 0.00;

}

ounces = units * 0.035274;

Serial.print(units);

Serial.println(" grams");

delay(1000);

if(ounces > 0)

{

digitalWrite(13,HIGH);

delay(20000);

digitalWrite(13,LOW);

// iterate over the notes of the melody:

for (int thisNote = 0; thisNote < 8; thisNote++) {

// to calculate the note duration, take one second divided by the note type.

//e.g. quarter note = 1000 / 4, eighth note = 1000/8, etc.

int noteDuration = 1000 / noteDurations[thisNote];

tone(8, melody[thisNote], noteDuration);

// to distinguish the notes, set a minimum time between them.

// the note's duration + 30% seems to work well:

int pauseBetweenNotes = noteDuration * 1.30;

delay(pauseBetweenNotes);

// stop the tone playing:

noTone(8);

}

exit(0);

}

// no need to repeat the melody

}

We first put the libraries of both the HX711 and the Pitches for the tone at the top, then we grouped all the void setup according to the sequence of how the programming should flow. The weight sensor's detection first, followed by the LED lights and finally the toneMelody. This was done the same for the void loop. exit(0) and a command to NOT repeat the melody was written at the end of the whole code.

While we were merging the codes together, we realised we had gotten our calibration code wrong as the weight sensor was not detecting anything. So we had to re-calibrate everything, which gave a new calibration factor of -31000. Quite a bit of difference from the initial huh......

This is a picture of Aqilah trying to painstackingly form the codes while Jia Min was dealing with the Cura settings for our 3D Printing.

Aqilah's perspective on the Arduino Programming process can be found on her blog, which is linked above.

Part 5. Integration of all the parts

(Done by Jia Min: https://jiamin20.wixsite.com/cp5070-2b07-2-jiamin/post/project-development-%D9%A9-%E1%B5%95-%E0%B9%91 )

Now, for the finalisation of our product, we had to integrate them altogether. Additional materials were needed such as skewers, reflective sheets and corrugated board, along with the 3D printed and laser cut materials.

The steps to assemble all the parts together are as follows,

1. Connect the base and the lid using skewers

2. Slot the weight sensor beneath the base and wrap the wire of fairy lights around the skewers

3. Paste the reflective sheet onto a clear cupboard and stick it outside the box

4. Take the laser cut black opaque acrylic sheets, and cover the exterior of the product with it entirely

Product constructed!!!

Hero shot with final product :)

Further details of the final integration process will be shown in Jia Min's blog, which can be accessed clicking on the link provided on top.

4. Problems and Solutions

During the whole process of this problem design, we encountered multiple problems. First, our initial idea was to create a sliding mechanism to allow the box to hold multiple different sized phone. However, we were troubles designing the mechanism on Fusion 360 and making it fir aesthetically into out box. Thus, after consulting with Mr Ting, he suggested an idea where we can built a long wall inside the box to hold the phone in place. That was good idea, but we were worried that that will increase the light pathway to the phone which defeats the purpose of out sterilisation box. After brainstorming for a while, we decided on using the idea suggested to us but make the box itself more fitted, so that the handphone will be propped up without a long wall holding it together. That made the design and printing process easier for Jia Min. Mr Ting also suggested that we only print the base and the lid, which solved our problem taking over 8 hours to print our product.

Another major problem we encountered is the calibration of the weight sensor. This problem took us almost a week to master. Because this was our first time using a weight sensor, we had to purely rely on the internet to guide us through the programming of it. However, no matter what we did, there was no reading during the calibration step even with the know weight on it. This was a huge problem as only after we calibrate the weight sensor with a known weight, the weight sensor will be able to read the weights of other problems as well. We were already stuck on the first crucial step. Thinking that it was the code's issue we used multiple different source codes for the calibration of HX711, but to no avail. We even changed the set-up of the weight sensor and still nothing worked. Frustrated, we consulted DR Noel, who checked the conductivity of our wiring. Turns out, there was not enough resistance in the wires we used, so no signal was delivered to the Arduino, resulting in on weight readings. Hence, we re-wired and re-soldered everything, making sure the new wires chosen had sufficient resistance using a multimeter. From then on, everything started coming together and we managed to figure out the code.

5. Project Design Files as Downloadable Files

In this last section, it is linked to a google drive with all the files we used during the product development process such as the Fusion 360 file, the Arduino code, STL file and so on.

You can access the link here:

https://drive.google.com/drive/folders/1h48YbVjI_W_ToxZ_yVm0ocHDWtnMP2nk?usp=sharing

With this, this marks the end of our CPDD journey. It has been sometimes a painful, sometimes stressful and sometimes exciting, but through this module, I feel like I am better equipped to take on bigger projects for Capstone. I am now more aware of what I can contribute to the group so that a more efficient task allocation can be executed.

Thank you for keeping up with this amateur blog!