Month: March 2019

This week, our team made progress in many areas of the project. We are also beginning to put our subsystems together and testing them with each other, and our project as a whole is beginning to take shape. Overall, the team worked this week on preparing for the demo next Monday, which resulted in our progress of being able to trace out basic shapes using our gantry system and motor control software.

There are no new significant risks for our project that we observed this week or that we can foresee occurring. The preliminary tests and experimentation of our prototype gantry is working as we expected with little to no issues. As we continue finalizing our robot and connecting our subsystems together, there still remains the risk that the subsystems do not interact as we expected. However, our careful planning makes this risk very unlikely, and any issues we do encounter can probably be easily dealt due to our planning and design.

No significant changes have been made to our design, and the realization of our robot is going smoothly and as planned. There are no major changes to our schedule, as our progress this week as a team has been on schedule.

 

This week I completed designing the stroke algorithm and wrote the code for it. Using Chris’ stroke plotting function, I was able to simulate the drawing of both the outline strokes and fill-in strokes. The outline stroke algorithm is very quick and can draw outlines for complex images in under a minute. The fill-in stroke algorithm is quite slow. Complex images take 10’s of minutes to completely finish drawing, depending on the brush width. Last week I had said that I would finish the design of this algorithm and have simulations by this week, and I fulfilled that goal.

My progress is on schedule this week because I have finished the requirement for demo day for the software part. The goal was to finish the algorithm and the simulation framework. Since the algorithm took very long to finish, Chris helped me by constructing the stroke plotting functions. I’ve tested the algorithm on multiple images, so it works for sure. This means that all that is left for the stroke drawing algorithm are optimizations to the algorithm and how the code is written.

For the next week, I will start testing the stroke drawing on the physical system. However, Eric and Chris would have to make sure all the controls work before that, so while they work on that, I’ll work on optimizing the code. Since it runs very slowly for fill-in strokes, I’ll have to either come up with some optimizations that make it faster (such as removing for-loops and using more optimal data structures), or porting the code into C++, which is a much faster algorithm.

This week, I worked on the gantry control system and made significant progress. Early in the week, I connected the servomotor to the Pi and tested our ability to control the servo with the Pi. I wrote a test file for testing the servomotor, which proved that we could precisely control the servomotor to go to a specific angle. I worked with Chris on finishing the preliminary code for the gantry control system, which contains several control functions involving manipulating the servo and stepper motors to perform tasks. I wrote a new test file for testing the stepper motors, and experimented with several different motions and controls to ensure we could manipulate our stepper motors in the way we desired.

My progress is on schedule this week. I was able to wrap up setting up the hardware for our project, which includes the Pi, the motor shield, the stepper motors, the servomotor, and the connections between these parts. I finished the preliminary code for the gantry control system and I extensively tested the control of our motors.

In the next week, we will begin testing our system as a whole, and ensuring our subsystems are correctly interacting with each other and performing our desired tasks. We will also deal with any issues that may arise from testing. I will modify our code to account for any problems that may occur, or to make our software more efficient and accurate.

This week I was able to complete the construction of the gantry and begin simple operation of the gantry. This involved printing the remaining parts, attaching all of the parts to the frame after our screws arrived, and calibrating the system in the Makerspace using the levels and tools available there. The completed gantry can be seen in the image below.

In addition to completing the construction of the gantry, I assisted Eric in writing the control software for the gantry. This involved writing control routines such as moving to a specified xy coordinate, initializing the gantry system, moving to a designated pigment in the palette, rotating the servo to make contact with the board, and drawing a specified stroke at a given location. This code is in a prototype form but this layer is completed and can start to be tested on our gantry. I worked with Eric to develop more test suites for our stepper motors in our gantry system, and created simple commands which allow us to move the head, draw lines, and draw a square. This functionalities are shown in the following videos.

I also assisted Harsh by creating a test suite for the painting algorithm which can create a digital model of the strokes which would be delivered to the gantry control layer. This allows Harsh to continue making process and allows him to rapidly debug his code, and also ensures that as long as his code is compatible with the test suite, it will match our gantry layer so long as we successfully implement the single function which the painting algorithm uses.

Overall this week I have remained on schedule. My tasks for the week were to complete motor integration, develop the motor control routines, and control the paintbrush. All of these tasks have been accomplished, which lead into the tasks for the following week which are to test all of the color grabbing and stroke routines on the physical system and begin testing the painting algorithm on the physical system. Eric and I will be working closely together to make sure the gantry control layer can successfully run the routines as expected and offer correct interfaces to the painting algorithm.

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.

In the beginning of this week, most of my time was spent working on the team’s design review report. In addition to writing my contribution to the report content, I compiled and formatted the document at the end. The Raspberry Pi order has still not arrived yet, so I am still unable to directly work with the Pi. I created a GitHub repository for the team’s code, and continued working on the code for the motor controls. I am encountering some difficulties in using the library, which I may need to solve by installing Linux on my computer.

My progress is a bit behind schedule, because I was unable to complete most of the motor control code before Spring Break began. To make up for it, I will push myself to complete the code soon after break ends. The process will also surely be expedited by the arrival of the Pi and being able to actually test the code. In the week after break ends, I plan to finish the majority of the code for the motor controls and test it on the Pi once it arrives.