Category: Erin’s Status Reports

Over the past weekend and week, I worked with Mohammed to start integrating the control logic of the servo with the model classification results. We also did some unit testing of the different subsystems and worked on the final presentation. We ran into some issues during testing of the servo, which we were able to narrow down to mechanical problems, which have now been fixed. Over the coming week, in addition to all the documentation that we need, I will be working on finalizing the integration of the control logic of the servo and classification model. We also plan to conduct final unit testing for the sorting sub-system, as well as whole-system accuracy, which we were previously unable to do. 

This week, I worked on setting up the user interface for the project and running the server on the Jetson. I was successfully able to transmit user input for speed (via the sliding bar on the monitor connected to the Jetson) to the Arduino, which consequently sends the appropriate PWM signal to the motor driver, resulting in setting the speed. I experimented with the different minimum and maximum speeds that the motor could handle, and accordingly constrained the user input to within reasonable bounds that do not provide current issues. The power supply we previously used for the demo had a current limit of 0.25A when supplying voltages greater than 6V, so we switched to using a different power supply with a greater current limit, which also allowed the motor to spin faster. Upon initial testing, we are able to get an object from end to end of the belt within the 5 seconds that was specified in our use-case requirements. With further testing this weekend, we will gauge whether we can also classify an object in time, and will accordingly modify the speed constraints. In addition to this, I also worked with Mohammed on getting some sort of live video stream of the inference and classification on the website, which eliminates the need to have another window open with the live inference. Over the weekend, once the ramp is built, I will be working with Mohammed to integrate the control logic of the servo with model classification results, unit-testing the different subsystems of the project, and also fine-tuning and synchronization to make sure the ramp moves at the right time. 

Additional Questions
Throughout the course of this project, I watched tutorial videos online to learn how to accomplish tasks that I was previously unfamiliar with. For example, when figuring out how to drive a motor with custom specifications, the video on the GoBilda website walked me through how to use the motor specifications to send out PWM signals. In addition, I’ve also had to look into open forums online when running into specific problems, which has also been helpful. For the User Interface, I took a Web Applications course last semester, which gave me a lot of the background I needed to be able to design and interface with the website.

This week, I worked more on setting up the electronics for the conveyor belt in time for the demo. Currently, we are able to use one power supply to move the conveyor belt at a fixed speed and simulate the servo moving every 5 seconds. This is approximately how it will be when we integrate the classification signals into the system. In addition, I set up the web interface on the Jetson, and early next week, I plan on writing a framework allowing us to change the conveyor belt speed. I will also be working with Mohammed to integrate the classification signals into the project. I anticipate running into a bunch of timing issues, specifically getting the ramp to turn exactly when the object is at the end of the belt; however, with some experimentation and synthesized delays, I’m sure we will be able to navigate this. 

To verify that the subsystems I am working on meet the metrics, we have a set of comprehensive metrics and tests:

Selection of bin in < 2 seconds
Run 20 trials of placing random objects on the belt, and record how long it takes for the ramp to turn to the bin of the material it is classified to be. The average will be a good indicator of if we met our target.

Reaction to controls < 400ms
Run  5 trials for each actuator (servo and DC motor), and start a timer when an instruction is sent using the Jetson. The measurement will end once the actuator completes the instruction, (a change in speed for the motor and rotation for the servo).

Depending on the data that we collect from our comprehensive testing, we may have to further tune and improve parameters in our system to help meet benchmarks.

This week, I did the setup for the web application that we plan on using to control the speed of our conveyor belt system. We will be using Django to run this web application. I also looked into the different modules I will require to be able to get live video feed from the camera integrated into this webpage. At the moment, there is a rough sliding bar on the website. Over the weekend, I plan on working on the design and feeding inputs to the page to the motor driver. 

I also found a useful tutorial on implementing video streaming from the OAK-D Camera with OpenCV and Flask modules, which I will be experimenting with over the next few days.

This week, I wrote the infrastructure to get the Arduino to communicate with the servo for our sorting mechanism. I drove the servo with 5V from the Arduino. However, I noticed that the reason that worked was because the no-load current of the Arduino was 190mA. With a load (which we will definitely have when we integrate the servo into the mechanical build of our product), our stall current goes up to 2000mA, which is way more than the Arduino can safely handle. Because of this, I will need to power the servo with an external power supply, which I intend to experiment with in the following week. I also wrote the infrastructure to drive the motor through the motor driver and Arduino however, this also needs an external power supply due to the excessive current draw. In addition to this, I plan on starting the UI powered by the Jetson and establishing communication with the motor.

This week, I received the items that I needed to start testing our actuation mechanism and belt mechanism. Over the weekend, I started to familiarize myself with the yellow-jacket motor and motor driver and experimented with getting the motor to communicate with the Arduino via the motor driver. I plan on continuing this over the next week and developing a robust framework to help us integrate this code into the main project. As mentioned last week, I will also attempt to communicate with the goBILDA servos.

The week before spring break, I worked on the design report alongside the rest of the team. We also ordered the parts necessary for the initial build of our project. We anticipated a week lead time, so the products should be in ECE inventory by the start of the coming week. My goal for the week is to work on getting the Arduino to communicate with the motor driver, and get the yellow jacket motor spinning. In the product description, we found a tutorial for interfacing the motor driver with the Arduino, so I don’t anticipate any hiccups in this process. If time permits, I may also try to get the Arduino to communicate with the goBILDA servo that we purchased. In addition, we plan to start and finish building the base mechanical belt structure over the course of the week.

This week, I gave my design review presentation to section E. By the time it came around, we figured out how our different subsystems were going to interact with each other. Later in the week, I met up with my team to finalize the BOM for our project. We also figured out how we were going to acquire the Arduino; we will be placing the order for the servos from goBILDA early next week. My goal before Spring Break is to experiment with the Servo Library for Arduino with hobby servos that I have lying around, and once the servos for the project arrive, I’ll work on driving it for our purposes.

This week, I met with my team to prepare for our upcoming design review presentation. Our goal was to fully think through the separate design aspects of the project, and hash out details. Because we changed our sorting mechanism (described in further detail in the Team Status Report), we had to rethink all the different parts we would require to get the system to function properly. I contributed by creating an in-depth block diagram that highlights all the system interactions. We plan on adding further detail before our design presentation; However, creating the diagram helped us better understand how we wanted our system to function. We’re still on track with the schedule proposed in the Gantt chart. My goals for the following week are to place some integral part orders (Servo, Arduino, Camera) and to also start experimenting with servo libraries on the Arduino to figure out how to properly drive a servo rated for a larger than typical load. 

 

Personal Accomplishments
Mohammed and I worked on booting up a spare NVIDIA Jetson Nano that we had. The process was fairly straightforward, from flashing the SD card to creating an account. The only hiccup we encountered during bootup was the plugin of any external device causing the system to shut down. However, we overcame this very easily by using a power supply better rated for the product.

In addition to this, for our project proposal, I created a block diagram to help us efficiently isolate the different aspects of our system architecture, and think of how we were going to implement it ahead of our design review presentation in the coming weeks. I also helped in finding parts for our parts list 

Schedule
Currently, we are on track, however, we are approaching milestones in the coming days, including the system architecture design. 

Deliverables
My upcoming goals for the coming week include solidifying the parts list, placing orders for essential components, and also working with John to properly hash out the servo actuation mechanism and how it is going to interact with the whole system.