Author: vasudhas

This week, I spent time working more on the mechanics and helping out on the software model side. On Sunday, I worked on assembling and testing out a temporary set up that would allow me to perform end to end testing from the capture to platform turning. This setup was not completely built, with temporary parts such as a taped paper platform and the camera capture mounted on a separate table, but showed me what the results would look like once the mechanics were fully built. I then ran multiple tests to get last minute records of our device’s time and accuracy performance to put in our presentation slides. 

Later in the week on the mechanics side, I connected the acrylic door to the axle, powered the hardware, and ran tests to make sure everything was working. I also tested this set up with the newer clamps and ended up going with the older one as that was easier to integrate in terms of alignment. After testing the acrylic door, I found that it was definitely on the heavier side, and the clamp setup is not very stable. However, it works, and hopefully should be enough if we are not able to further develop the setup by the demo. I also worked with Ting to cut and build the camera mount, which was attached to the back of the servo frame, giving that frame some additional support at the same time. The overall structure of the device is not very stable, with the wooden parts often warping/disconnecting from the acrylic. Now that I have a better idea of how to assemble the frame, I have been thinking about redoing the connections and using bolts instead of screws to connect the wooden parts to the acrylic if there is time before the demo. 

On the software side, our model implementation has not been performing well. Therefore, I spent some time helping out with debugging, looking for newer datasets, and sorting through them to integrate into our current implementation. 

Schedule wise, I am somewhat on track in the sense that progress is being made, and our device is almost fully constructed and integrated even if the individual parts are not developed to their optimum levels. In terms of mechanics, the only crucial part that has not been implemented is the installation of the locks, which as a last resort solution we might end up taping to the system. 

Given the remaining time in the course, next week I plan to try and finish off the required finishing touches for the mechanics, help out with the software, go back and see if any mechanic parts could be improved, and work on the final submissions.

This past week, I mainly worked on the mechanical portion of the project. First, I spent some time marking out my pieces. I marked out the door and places to make holes for the acrylic piece, then the specific measurements for the wooden legs and door frame. I then learned how to use the laser cutting machine and the drawing tool, and marked out my specific measurements for cutting the acrylic on it. I cut the acrylic in three different sessions after seeing what I needed to connect the parts, one initially for the door, one for the frame holes, and one for the door holes. I then got some of the wooden pieces cut with the help of the TechSpark staff, and then cut the remaining pieces by hand using a hand saw. I then learned how to use a power drill, drilled holes into the wooden parts, and then tried screwing them together. I also added corner braces to the connected legs, and then connected the wooden frames to the servo and to the acrylic frame. After this, I tried working on the door, and while alignment was okay with the larger clamps to hold the axle, it was quite loose and hard to stabilize (used a lot of popsicle sticks and tape). To account for this, we have ordered smaller clamps to see if it will be easier to install. Additionally, when trying to put the servo frame + legs + door + acrylic frame all together, the overall frame was not very stable, and seemed better off if initially assembled without the legs (which were uneven and short due to the last wooden piece holding them up not being installed yet). Due to this, along with the fact that I have yet to cut holes to install the locks, and other complications with alignment, I will probably have to uninstall the legs and focus on fixing the rest of the pieces. 

Next week, I plan on finishing the basic lid assembly and start integrating it completely with the hardware so the overall testing of the mechanics can begin. This has already been done with the main servo, and I will focus on installing the locks and the door to the axle so everything can be tested together. 

In terms of schedule, while I was initially on schedule, due to complications and the learning curve for the tools, I think I have now fallen behind in terms of the mechanical building. However, now with a better idea of what I need to do and the remaining parts needed, I think I can make significant progress before the final demo. 

This week, I spent time prepping for the interim demo and starting mechanical construction. For the demo, I focused on getting the hardware system ready. The main circuit and operation was constructed a few weeks back, and I spent some time making sure the integration of the Jetson and Arduino worked. I wrote a script for the Jetson to take the output of the model and send it to the Arduino rather than the initial hard-coded test script I was using. As the demo neared, I began having issues with the Arduino port switching when multiple model outputs in a stream were sent (when trying to have multiple rounds of waste being sorted). I spent some time attempting to research and fix the issue, and will continue later this weekend. On the mechanical side, I finalized the remaining parts that we needed and put an order in early in the week. I then used the Techspark laser cutter to cut our acrylic frame and door. Once the parts ordered arrived, I assembled our axle structure and aligned it to the servo so it turned the right amount and direction. 

My progress overall aligns with the newer schedule. However, I might need to spend a little more time on the Jetson Arduino integration, as while it works for one iteration before the port resets, it is important that it works for multiple inputs. Mechanical construction has also begun so I am on track for that as well. 

Next week, I plan to finish constructing a good portion of the main frame (making holes for the screws in the acrylic and hardware cables, connecting the door to the frame) so that we can start integrating the hardware, and see if I can solve the port issue. 

In terms of testing, I have been conducting a few tests as each part of the hardware subsystem was built, mainly in regards to operation accuracy (which is one of our most important requirements). While integrating each component (neopixels, speaker, and servos), I did them one at a time, and made sure they either displayed the correct color, produced the right sound, or turned the right direction. After this, I tested multiple components at once, initially making sure that the color, sound, and directions were correct, then adding in delays, specifically for the servos, so that the correct lock unlocked before the main servo turned so that the door doesn’t get stuck, and the lock closing after the door returns back to place. After making sure the logic for all the components together were correct based on the model value that the Arduino would receive (fulfilling the requirement for the correct alerts and door movement being produced), I started working on Jetson integration. First, I tested that the correct hardcoded value was being sent over serially, then tested multiple, then tested actual integration with the output of the model. As I work on the mechanical door, I will have to test and tune the angle and direction of the servo now with the additional parts attached to it. Additionally, once the door works, I will increase/reduce the delays currently inputted so that the door works properly and as fast as possible without getting stuck with the locks (another requirement). 

Going forward, once the system works accurately, I plan on testing individual times and attempting to reduce them so that overall system operation time is reduced as having our system operate each round in less than 5 seconds was one of our defined requirements. I will make sure the door operation takes less than 2-3 seconds, and the overall circuit begins to operate within one second of model output.

This week, I focused on making sure the integration between the Jeston and Arduino worked and finalizing the mechanical design so that we can officially start building this following week. As of last week, I was only able to get 1 value sent from the Jetson/received by the Arduino. The Arduino was working correctly in response to the specific value it received. However, when testing a string of inputs from the Jetson, the Arduino seemed to only output the result of the first input, making it seem like there was some buffer issue. Eventually, I was able to fix this, however, the transmission+receive time is a little too slow, and was something that I continued to work on for the rest of the week to improve. On the mechanical side, a few things occurred. The acrylic piece that we had ordered for our previous door design arrived, the Professor had provided us with wood pieces for our frame, and I talked to people at Techspark regarding purchasing plywood from them. The plywood pieces at Techspark ended up being too small and thin for our purpose, while the acrylic seemed to look like the better option, with some tweaking with the wooden pieces. With all of this in mind, I once again modified the mechanical design to now use the acrylic piece as the lid and door, with wood pieces on each side to create for the axle to then be attached onto using clamps. The overall acrylic lid will be connected to the wooden frames. I made a few drawings (shown in the team report) and decided on measurements that we can then provide to Techspark next week so that we can start cutting out our pieces and start building.

We are on schedule, prepared for the interim demos this following week, with the software and hardware subsystems somewhat operating successfully (though the integration of getting actual model output values rather than a script being sent to the Jetson still needs to be implemented). While there are a few issues with our implementation that we will need to go back and resolve (ex. Further fine tuning and getting proper outputs from the model in a format that can be sent to the Arduino), the individual parts are showing some form of operation, which we hope to improve upon in the next few weeks as we continue to integrate. 

My next steps for the following week are to successfully complete the demo, start mechanical building, and help resolve the format issue regarding the model output and Jetson+Arduino integration.

This week, in addition to the ethics assignment and lecture, I focused on setting up the hardware circuit and helping debug the camera set up. For the hardware circuit, I initially attempted setting up the circuit according to my simulated MVP design. However, I soon found that some of the parts were not exactly the same as the ones in the simulation, and therefore could not be connected the same way or use the same libraries. A big example of this was the neopixel strip, which was actually the “Dotstar” version that used SPI, therefore needing a separate clock and data line. I therefore had to move the neopixel strip pins to use 11 and 13, as those were the pins on the Arduino Uno that had  the MSIO and CLK SPI signals. Besides this, the speaker and the servos could be connected as per simulation. After some debugging, I was able to successfully connect and operate the neopixel strip, servos, and speaker. After this, I added code to have the Arduino accept and use serial input, connected the Aduino with a usb to my computer, and ran a python script to see if the Arduino would accept and correctly control the components based on the given input, which after some debugging, worked as well. The next step in this process will be running the input script on the Jetson itself to make sure the connection between it and the Arduino works the same way. 

After setting up the hardware subsystem, I helped Ting and Aichen debug the CSI camera connection. Although the device could recognize that a camera was connected, despite trying to install and use multiple streaming commands, none of them seemed to work. The errors produced by these commands seemed to  indicate that something might be wrong with the camera+Jetson connection itself, so we will try using the camera on the nano to see if there is an issue with the camera or the Jetson port, and temporarily use a USB camera in case the CSI one does not end up working.

I also worked on further fine tuning our mechanical design and specified measurements for the different parts of the frame and door. 

Schedule wise, we have now caught up in terms of hardware. We are behind on the mechanical side due to the constant revision of the plan and not having all the parts we need for the new design. We are also a little behind on the software side due to unexpected issues regarding the camera. Therefore, our plan is to focus our time fixing and fine tuning the software and the camera+Jetson subsystem so that we have that working with the hardware in time for the interim demo, and then focus more time on the mechanical portion once those parts arrive. 

This next week, I plan on testing the Jetson+Arduino integration and helping out with the camera/software debugging so that we get back on track and have everything ready for the demo the following week.

Last week, I focused more on helping out with the software side, and worked on debugging our 1305 GPU setup and code. Since a lot of libraries were missing and our code was in a Jupyter notebook format rather than a Python file, I went through, installing what was missing, fixing dependencies, and trying to get the code to run. This set up is a backup plan to the Google Colab set up that Aichen and Ting are working on, and since the hardware components have arrived, I will be focusing more on that set up to catch up in regards to our schedule. However, the software debugging is still something I am currently working on, and hopefully we will be able to figure one of these solutions out before the end of next week so that we can then migrate this code to the Jetson. 

On the hardware side, some of our parts had finally arrived. I started working on setting up the Arduino and respective components, and hope to have this fully set up and operating the basic design before integrating the mechanical aspect. After attempting to connect and operate the neopixels, I found that the type we had purchased did not match the simulated component (uses SPI communication and therefore requires a different library and extra pin connection for clock). Therefore the respective simulated programming did not work as intended, and will need to be modified.

In terms of schedule, while we are quite behind in hardware due to the delay in the parts arriving, we caught up a little on the software side, and plan to devote more time to the hardware this week to catch up. 

As mentioned, next week I plan on finishing up the the hardware component assembly and implementation of the basic design, and finish ordering parts for our final mechanical design (which we modified once again after discussion with the professor).

This past week, I mainly worked on finishing up the report and once again tuning the mechanical design based on feedback from the TA and Professor. For the report, I modified and consolidated our diagrams according to feedback to show both our use case requirements and design requirements, and created tables to organize some of the information in the report. Updated design can be found here: https://drive.google.com/file/d/15j3AFNqRnFr1QK4KOhniSD_vvZ2-SMlD/view?usp=sharing

I also worked on defining the abstract, design architecture, and information related to materials, hardware, and mechanical aspects of the project, and helped out with formatting to make sure all parts of the report flowed with each other. 

Earlier in the week, Ting and I met with Professor Mukherjee to set up the environment we needed to work on our project on the 1305 GPU machines. Using XQuartz, we set up pytorch using miniconda and created a shared afs folder to allow for our members to all access the project files. This setup process is something we had to learn in order to use the GPUs to train our model. 

The mechanical design and building aspect is something that we will need to continue to learn more about in order to properly execute our bin itself. During class, I worked with Ting to finalize the mechanical measurements for the bin given the newer set up with an axle. After feedback during Wednesday’s meeting, we found that the design that we had come up with (all acrylic, clamp to hold dowel on lid frame and other end glued/drilled into door) was mechanically weak due to the thinness of the material and the space we had we were attempting to drill into (ie. height and depth). We then decided to redesign the bin with as little change as possible to avoid having to switch up materials, this time having a wooden lid frame with support legs while maintaining the bin and acrylic door. This way we can more securely drill into the frame and not have the weight of the entire frame rest on the plastic bin below. I then looked into the new materials we needed for this implementation. 

In terms of progress, we are behind in regards to the mechanical and hardware portions since our ordered parts have yet to arrive. However, we have simulated the hardware parts and hope that by end of spring break, they will arrive so that we can begin building.

The week after spring break, I hope to have started the mechanical and hardware building and finish ordering any remaining parts from the new design so that we can catch up to our original schedule.