Leonardo Da Robot

Much of my time this week was spent preparing for our demo on Monday. This involved finalizing all of the control we were able to achieve and creating demo scripts or use during our actual demo. Additionally I worked on improving the software portion of our project for the demo by speeding up how the objects were filled in. This involved creating more sophisticated code for identifying continuous horizontal regions of the code. I also changed the library used for drawing the rendered image to speed up the debugging process and created a simple debugging stroke drawing option which sacrifices accuracy for speed in order to test changes faster.

This week I was also able to begin the construction of our base board which the frame and gantry will attach to. This involved carefully measuring and cutting holes in the board for the legs of the frame to slot into. This has been completed, and the remaining work in this area is to make cutouts for the palette and water cup, as well as to attach the mounts for the stepper motors. These parts have not arrived yet, so for this reason I shifted my attention to the software components mentioned above.

Overall my progress this week has been mostly on schedule. Ideally I would have finished the construction of the base board this week, but as this was not possible due to the missing parts I was able to shift my focus to the other portions of the project and assist Eric and Harsh where needed. Next week I hope to finish construction of the baseboard and we can move on to more extensive testing of our physical system.

Over the last week, our team has worked on getting the control system ready to test the painting routines including the color grabbing routine, the brush cleaning routine, and the drawing routines. We also worked on creating the base board and improving the painting algorithm. In the beginning of the week, our team spent significant time preparing for the demo on Monday.

There are no new significant risks for our project that we foresee occurring in the future. Our mid-project demo went smoothly and we were able to create a functioning gantry system and a robust painting algorithm. Small risks include the parts of the gantry system wearing out over time, but that is something we took into account in our design. This is the reason we 3D-printed a lot of our parts, so that we could reprint them if they wear out. Any other risks we encounter should be mitigated through our careful 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 is mostly on track.

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.