# P diddy has arrived

My friend and I recently got psyched about the new Makerarm, which is a simple, 3-axis arm. We decided to make our own, and here’s what it looks like so far:

It’s comprised of mostly 3D printed parts and uses stepper motors for its actuators. David, my friend, is programming this one, so I’m pretty hands off on that. When he gets it up and running (right now it can move, but it can’t do anything interesting) I’ll post a video.

Designed in Solidworks, rendered in Keyshot 5, printed on makerbots at the UMD startup shell.

Final note: he came up with the name

# My Delta Robot’s Inverse Kinematics

I basically made Arthur, my delta robot, so that I could play with the fascinatingly complex inverse kinematics equations required to get a delta robot running. In the same way that kinematic equations predict the result of a system, an inverse kinematic equation determines the system based on a desired result. In this case, the desired result is always a coordinate in 3D space, and the system is our delta robot with its lever arms at 3 different angles. The inverse kinematic equation takes in the coordinates and gives us the angles of the arms to reach those coordinates.

If you’re interested in understanding how this works, let’s dive in!

I separated the movement of the delta robot into 3 functions. The first, setLevers() is a simple function that sets the levers (the yellow pieces) to given angles. I’m going to skip over this because it is robot specific and basic.

```void setLevers(float f, float l, float r){ //f is front, l is left, r is right
if (f > 150 || l > 150 || r > 150 || f < 15 || l < 15 || r < 15){
Serial.println("inputs are out of range for lever arms");
return; // this checks for invalid inputs
}
// TODO: create another indicator that the inputs are invalid
int fcor = 275; int rcor = 350; int lcor = 375; //fcor = front correction
long upperLimit = 800; // upper limit ~= 800 = 125 degrees to straight down (((1900)))
long lowerLimit = 2300;// lower limit ~= 2300 = 35 degrees to straight down (((925 )))
myservofront.writeMicroseconds((f - 35)*(upperLimit - lowerLimit)/(125-35) + fcor + lowerLimit); // tell servo to go to position in variable 'pos'
myservoright.writeMicroseconds((r - 35)*(upperLimit - lowerLimit)/(125-35) + rcor + lowerLimit);
myservoleft.writeMicroseconds((l - 35)*(upperLimit - lowerLimit)/(125-35) + lcor + lowerLimit);
}```

The second function, leverCalc(), is mathematically intense, and this is where the angles of the levers are determined. It takes the coordinates of the desired position (x, y, z) and returns an angle for the lever.

The function starts by defining the lengths of the different linkages (P0,P1,P2,P3, as shown in the picture above) along with some variables.

I did the mathematical calculation for this by simplifying the structure into a 2D system for each arm of the delta. To do this, I also had to account for the lateral movement of the linkage of each arm. To adjust the length of P2 when it is projected onto my 2D plane, I created a new variable mP2 or modified P2. I set this equal to the project length by using pythagorean’s theorem (line 3).

Next, I eliminated P0 and P3 by subtracting and adding them respectively to y. Keep in mind that my 2D plane is the y,z plane, not the x,y plane. Using the new y, I found the hypotenuse (h) of y and z, which is also the length of the third side in the triangle created by segments P1 and mP2.

Finally, I used the law of cosines to find the angle between the hypotenuse and P1. I added that to the arccos of z over the hypotenuse to get theta in radians. At the end, I converted theta to degrees.

```float leverCalc(float x, float y, float z){
float p0 = 75, p1 = 150, p2 = 315, p3 = 50, mp2, h, theta; // refer to picture < picture of linkages > for explanations of names. all units in mm
mp2 = sqrt( pow(p2,2) - pow(x,2) ); // adjusts the linkage length to compensate for the tilt of the linkages
y = y + p3 - p0; // p0 is the distance from the base of the lever arm to the center of the lever arms
// p3 is the distance from the center of the tooltip to the bottom ends of the linkages
// This whole adjustment makes y (the change in y) the y distance from the base of the levers to the ends of the linkages
h = sqrt( pow(y,2) + pow(z,2) ); // calculates h. Refer to < picture of linkages >
theta = atan( y / z ) + acos( ( pow(h,2) + pow(p1,2) - pow(mp2,2) ) / (2*h*p1) );
theta = theta / PI * 180; // adjust theta to match setLever() parameters
return theta;
}```

The final function, moveTo, just calls the leverCalc function 3 times and adjusts the coordinates for each lever. Then, it does a quick check to make sure the values are in range. Finally, it sets the levers to the desired coordinates.

```void moveTo(float x, float y, float z){
float front, right, left, p2 = 315; // these are the variables for the lever angles
front = leverCalc(x, y, z); //calculates lever angle for the front lever
float ry = -y*sin(PI/6) + x*cos(PI/6); // adjust x, y, and z values for the left lever
float rx = -y*cos(PI/6) - x*sin(PI/6);
right = leverCalc(rx, ry, z); //calculates lever angle for the left lever
float ly = -y*sin(PI/6) - x*cos(PI/6); // adjust x, y, and z values for the right lever
float lx = y*cos(PI/6) - x*sin(PI/6);
left = leverCalc(lx, ly, z); //calculates lever angle for the right lever
// Throws error and prevents movement if the input is out of bounds of the mechanism
if ( atan(x/p2) > PI/6 || atan(rx/p2) > PI/6 || atan(lx/p2) > PI/6 ){
Serial.println("out of bounds");
return;
}
setLevers(front, left, right); // sets levers to desired angles
cx = x; cy = y; cz = z;
}```

The moveTo() function is rather basic, and I made a lineTo function (which is flaunted in the above video) that is much smoother. More on that in a later blog post.

# Developing the Delta robot

At the end of the spring semester, I stumbled across delta robots, and I immediately fell in love. Many manufacturing lines require extremely fast pick-and-place machines to pack boxes, reorient products, and most importantly, stack pancakes. For a long time, companies used slower robots for this task, but in 1987, Demaurex brought the new delta robot to the manufacturing industry, speeding up manufacturing lines across the globe.

The delta robot is so fast because it displaces all the weight of its motors to the non-moving top of the robot. This lets its tooltip be extremely light. The parallel linkages connecting the little arms to the tooltip keep the tooltip parallel to the ground.

Fanuc’s Various Delta Robots

My journey to making one of my own started when I discovered UMD’s new Makerbot printing lab, which offered incredibly cheap parts. Before this, I was paying around ten times as much for the same part. This let me design most of my parts for the robot and print them cheaply.

I started off by designing an elbow for the delta robot, but after I printed it, I discovered that the makerbot replicators were not up to the task of making acceptable moving parts. I went and bought ball joints and threaded rods for the linkages and went on to design what I call the lever arms.

Progression of my lever arm design

My first iteration, which is on the left, was disgusting. I designed it quickly in solidworks and sent it over to the makerspace. I got it back, and I was pretty disappointed with the part. All the holes were too small and the moving parts didn’t spin within each other. Furthermore, my design was pretty ugly.

The second iteration was miles ahead of the first. I gave the piece some aesthetic appeal, I gave all the holes and moving parts larger tolerances, and I brought the total material used down drastically. I also reduced the number of pieces by three. However, the mounts for the servo and axle were mediocre and flimsy, and the portion of the lever arm where the ball joints were mounted wasn’t up to my standards.

The third iteration was excellent. I bought some swivel hubs from ServoCity, got all the dimensions just right, and made the whole piece smaller, while keeping the lever arm the same length.

After I knew that I had the lever arm just right, I ordered two more. I also went ahead and designed the base of the Delta robot along with its tooltip.

I made the base a three-part assembly so that I could add new features and change the mounting stand without having to print a whole new base. I angled the lever arm mounts to change the range of freedom of the lever arms, which I believe will give the tooltip a large range of motion. If it doesn’t, it at least looks nice.

The tooltip is the bare minimum right now, but it has mounting holes that allow me to add two different pieces to it. In the future, I hope to eventually make a three-axis tooltip attachment (Fanuc’s six-axis Delta Robot)

At the time of this article’s publication, I have ordered / have all the parts in the above picture (besides the exact 80/20 extrusions) and I hope to have all the pieces by this Friday!

Have a good day everybody!

# A little update

A few days ago, I noticed that I haven’t written on this blog for six months, which is quite unfortunate. Let me update you on what I’ve been up to.

I got a job! I’m interning at Active Signal Technologies, which is a little company south of Baltimore. Right now, we are gearing up to produce noise immune stethoscopes, which are stethoscopes that medics can use in medical evacuations on helicopters or vehicles. I’m helping out by designing, modeling, and making different parts, jigs, and drawings (I’m using solidworks). The jigs below are used to hold piezoelectric magnets to their mounts while they are glued together in an oven. I just sent out the approved drawings, and I should be getting them soon 🙂

I was inspired at the end of the semester by the ABB Flexpicker, and now I’m embarking on my own adventure to make a delta robot. The first time that I saw it, I fell in love with the insectoid nature of it along with its extreme efficiency. Determined to make one to play with, I got a little bit of money together, and I’ll be 3D printing most of the parts. I’m currently on design iteration 3, and I’m waiting for the parts to print at the University of Maryland Makerspace. Here’s my current iteration of the arm.

Delta Robot Arm (iteration 3)

If you’re familiar with delta robots, you’re probably thinking “heh, this guy’s an idiot. He doesn’t have ball bearings!” I do, they’re just not in the current CAD assembly.

Finally, I just got a suggestion for another Mecanum wheel mount (thanks Sean Forrester from FTC Team 5916!), and I’ll throw that into the Shapeways marketplace in the near future. This one lets you attach Mecanum wheels to .77″ profiles, which are popular in the Servo City extrusion lineup. Here’s a sneak peak:

Mecanum adapter for .77″ Profile (WIP)

I’m doing this in inventor not because I like it, but because I’m just modifying a previous model. I prefer Solidworks to Inventor, although Inventor does have some perks.

# Just Started Submitting ideas to Quirky!

As a college student, I really don’t have the time or resources to build a bunch of random projects… but that doesn’t mean that I can’t waste away a day designing things in CAD! I discovered Quirky around six months ago, and I’ve been meaning to submit ideas to it, but I never got around to it. So yesterday, bored as hell, I decided to finally open Autodesk Inventor and design some products.

My first idea for quirky is simple and sweet. I came up with it in a meeting where the audience was told to make an invention for ramen noodles (it was a interest meeting for Quest if you’re familiar with UMD). I suggested a solution for determining when the ramen was too hot to eat. I talked about having a small indicator material that turns a certain color when the soup is cool enough to eat. My group ran with the idea and made a colorful presentation. After the presentation with the ukelele, I was interested in pursuing the idea, so my mind ran wild for a few minutes, and I imagined a few different utensils and dishes with incorporated temperature-sensitive materials. I found some temperature-sensitive, color-changing glass on inventables, and I finalized some concept designs in my head. I came up with a few utensils and dishes that had small color-changing glass rods inserted into them for determining when food was too hot to eat. Then, two months later (yesterday), I designed the product to submit it to Quirky.

Right now, the product is undergoing community evaluations. The community needs to vote it up so that it can be evaluated in an expert review. If you want to help me out, you can go to my product page and give it a thumbs up!

Right now, the product is undergoing community evaluations. The community needs to vote it up so that it can be evaluated in an expert review. If you want to help me out, you can go to my product page and give it a thumbs up!

Recently, I’ve gotten quite a few people interested in the VEX mecanum wheel adapters, and many people have also bought the 3D prints from shapeways or the stl files from me. I’m pretty happy about it all 🙂 Anyways, it inspired me to make some new adapters to make them more appealing to everyone. I, of course, decided to reduce the total plastic used to reduce the cost, and I’ve had some great results. With my new adapters, which are in beta right now, I have reduced the cost by 43% down to \$39.90 for a full set. I have also added an option to not buy the back clamps, which is only \$29.90 (57% reduction in cost from version 1). I’ve also made my parts look super fancy.

I’m still determined to reduce the cost further without sacrificing the structural stability.

Another fun thing that I’ve started doing is making another adapter for the matrix system. This was a request from a team in South Africa called the Creepy Crawlers. I don’t see this part selling much, but the adapter was harder to design, so it was more fun to make. Here’s the part so far:

After I finish these models, I’m going to redesign all the NXT motor and sensor adapters. I’m also going to make them free to the public 🙂

# The Oasis Chassis

The Oasis chassis is something that I designed over summer break while I was grieving the loss of FTC (It’s so sad to not have FTC…) Every year we spent too little time designing the chassis, and we would always have some annoying problem with it during the season. With ring it up, we sadly discovered that our omni wheels couldn’t hurdle an object on the playing field. Similarly, before we put mecanum wheels on Sheila, she had a terrible two-wheel drive that would often skid around. So even though I’m not participating in FTC anymore, I decided to go ahead and make a chassis that I liked while I was waiting for college to start.

My first version just focused on the drivetrain. I wanted a flexible drivetrain that could be easily modified (I designed this before the game release). I used sprockets and chains along with plates with multiple holes for the axles. This way, I could switch around the sprockets for different speeds and I could raise or lower the wheels to get over higher objects.

After designing the Oasis, I laser-cut pieces of HDF for test plates on the side. I also used my VEX Mecanum Wheel adapters on the Mecanum wheels. I then tested the chassis and developed my mecanum drive and superdrive tasks on it. I’ll talk about these in a later article, or you can just look at them on github.

After making sure that the drivetrain worked well, I designed a second version of the Oasis that incorporated more mounting points and a stronger frame.

As a finishing touch, I added a six-bar lift to demonstrate how easily I could attach more components to the chassis. The 80/20 extrusions on the sides can also be replaced with tetrix c-channels. I never made this version.