Author: hyallapa

This week, we had the mid-project demo. The previous week, I had created the outline-strokes and the fill-in strokes, as well as come up with an initial color choosing algorithm. Chris decided to make the fill-in strokes faster, so I was left with making sure that the color-matching algorithm was robust. Initially, the algorithm was picking colors such as yellow and orange for the green. The same inaccuracy was true for other colors. After changing the weight values of the 3 HSV channels, I was able to make the algorithm quite accurate. This is what we demonstrated on the mid-project demo day. However, there were still a few inaccuracies, especially with the greens. We then decided to both improve the weight values through experimentation and also make sure that the stored palette color values were accurate. After making sure that the HSV values were perfect and improving the weights further, I ended up with a nearly perfect color choosing algorithm.

My progress is mostly on schedule this week. I’ve finished perfecting the color choosing algorithm. Since there were lots of software tasks left, most of the physical system had been built, and the remaining tasks required parts which had yet to arrive, Chris helped by making the fill-in algorithm faster (using matrix operations in python), and creating a faster plotting function. The other task I’m supposed to be finishing up soon is testing the painting algorithm on the gantry system. However, we were slightly delayed on that part, so I haven’t started testing yet. To make sure I catch up, I will spend extra time during Carnival to finish testing.

For the next week, I’m scheduled to work on testing the painting algorithm, and helping Chris and Eric with their tasks, since the software algorithm is more or less complete. This includes tasks such as calibration and optimizing the painting routines.

This week I worked on writing and begin the testing of the stroke generating algorithm. As mentioned in the design report, there are two stroke types. The outline stroke draws the outline of one segment, and the fill-in stroke fills in that object. They are both of the same color and made up of many line segments. The algorithm for the outline stroke involves using contour finding through the OpenCV library, and then turning the outline curve into a list of ordered points. This is done by following the boundary of an object and storing all the points. Then, evenly spaced points are placed along the curve to turn it into a list of line segments. The algorithm for the fill-in stroke involves going from top row to bottom row of segment. Each row has a width of the brush. Its starting x-coordinate is the mean of all the starting x-coordinates in the row and the ending x-coordinate is the mean of all the ending x-coordinates in that row. I’ve also started to design a framework to test this without having to use the actual robot. This will be a simulation of drawing strokes. I also helped 3D print a batch of clamps.

My goal is to demonstrate the working algorithm on the simulation by midpoint demo day. Thus, I am slightly behind schedule. However, if I finish writing the algorithms by Wednesday and work on the testing and simulation framework after that, I will be able to complete all the requirements by midpoint demo day.

My goal this week is to finish writing the algorithms and continue developing the testing framework. I hope to be done with writing the algorithms by Wednesday. I should have the framework complete by the end of next week.

This week, our Raspberry Pi finally came in, which allowed me to work directly with the Pi. To prepare for working with the Pi, I partitioned my hard drive to install Linux alongside Windows on my laptop. Once I received the Pi, I set it up by installing Raspbian on it. I successfully connected the motor shield to the Pi, and the stepper motors to the motor shield. I tested the functionality of our stepper motors by running some test code, which was a success. This successful test shows that we are able to finely control the stepper motors as we wish, as well as that the libraries we chose to use for the motor shield are working correctly. I also updated the framework for the motor control code.

My progress is slightly behind schedule. I was able to set up the Pi, the motor shield, and the stepper motors, but I have not yet tested our servomotors with the Pi. I also have not made significant progress on the gantry control code, as most of my week was spent on setting up the Pi and testing the functionality of our parts. However, this is not a large setback, as the work done this week was still significant progress and helps facilitate the future tasks related to the Pi.

Early in the next week, I will complete a preliminary test of the servomotor. Following that, I will continue working on the code for the gantry control routines. By the end of the week, I should have a basic version of the control routines completed, which I will be able to test on the motors using the Pi.

This week I was able to begin construction of our gantry. This included finalizing all of our 3D printed parts and the construction of the frame. A majority of our parts have been printed, and those that are not are to be printed once the makerspace has a printer available. The construction of the frame is completed, and we now have the outline of ourgantry standing on four legs. Due to an ordering mistake on my end, we did not have enough screws to attach all of the bearing mounts to the legs, so not all axes are in place yet, however two have been added and are functioning well. I have also been able to test the method of attaching the motor belts to the carriages and this has been successful. A modification to the orientation of how the carriages are printed resulted in a much more sturdy version, as the previous versions had worked but the tabs for connecting broke off easily.

I was not able to fully complete the gantry construction this week due to an ordering mistake and this has put me slightly behind schedule. This will be very easy to rectify, however, as the parts needed should arrive next week and allow me to quickly finish up the gantry. A possible issue which I have noticed once having the axes in place is that the rods in the bearing mounts have very little extra space, and it is possible that they actually slip out of the mounts. This hopefully will not be a problem in operation, as the gantry will not be moving around, but we may have to glue the rods inside the bearings to secure them in place. This would be an easy modification to do but does make it more difficult to make modifications to the gantry in the future.

In the following week I will complete full assembly of the gantry, including all axes, carriages, and the print head. In addition to this I will help Eric and Harsh in whatever remains to be completed in order to have a demo ready. Currently I foresee this as being assisting Eric in creating and testing the control routines for brush movement and contact, or assisting Harsh in developing the algorithm and a test suite for it.

This week our team made significant headway in the 3 main components of our project; the gantry construction, the gantry control systems, and the painting algorithm. A single team member worked in each of these areas, and no significant issues have appeared in our design from what we have been able to achieve this week. The next target on our horizon is creating a short demo of the progress we have made thus far, and believe that we will be able to complete this comfortably in the following week.

No significant risks have appeared from what we have developed this week, but as our individual areas are being completed we are starting to consider the integration of each system. The integration is likely to have some issues arise and to control these factors we have clearly laid out the inputs and outputs of each layer and how they expect communication to happen. Given that we still have ample time left we do not consider this to be a serious risk to our success, but are considering how we can handle this process early to save time in the future.

Overall our progress this week has remained mostly on schedule. By our schedule this week should mark the complete construction of the gantry and the successful operation of our motors. While the gantry is not entirely completed, it will be entirely assembled in the next week, and enough is completed that it is not hindering progress in terms of controlling the motors. Motor control has been completed, and the painting algorithm is also underway.

No changes have had to be made to our design, aside from the development of a software model of the gantry system to allow for easier testing of the painting algorithm. This is not part of our final deliverables, but is a part of the development of the painting algorithm. This change was necessary as it allows for much faster testing of the software layer.

This week, I spent most of my time on the stroke generation algorithm. The first couple days of the week was spent on finishing the design review report with the rest of the team. After we submitted that, we got together and made sure that we had ordered all the parts so that we could build our frame and gantry system as soon as we got back from Spring Break. My main task this week was to work on creating outputs of the mean shift segmentation on all the images from the test bank. This way, we have pre-processed images which we can feed into our physical system.

I then worked on the stroke generation algorithm. This algorithm takes the mean shift segmented image as an input. It then turns the image into a list of strokes. There are two different kinds of strokes: perimeter strokes and fill-in strokes. Each object in the segmented image is made up of one perimeter stroke and one fill-in stroke. The perimeter strokes trace the outline of an object with the color of that object and the fill-in strokes fill in the object with horizontal straight lines of that color. The order of objects to be drawn is based on the length of the perimeter stroke, to make sure that the lowest detailed objects are drawn first. Once the strokes have been created and ordered, they are broken up into line segments which are defined by a starting coordinate, ending coordinate, and color. The color is chosen to be the closest color from the palette in terms of HSV values to the original color. This list of coordinates and colors is the output of this function that is sent to the control layer.

I am currently working on this function, and will use the break to finish it. Once I finish this, I will be on schedule. When I come back to campus after Spring Break, I will be working on helping build the physical system. We will have all of the parts by then and will need to focus on building this mechanical system first.