[0.000 --> 6.000]  This is a robot I calm. I like to call it Mark Wong.
[6.000 --> 15.000]  It's an Arduino powered robotic arm which features a claw for moving objects around, as well as six motors for better movement.
[15.000 --> 22.000]  And this robot can be programmed with an Arduino which means we can automate our favorite tasks.
[22.000 --> 25.000]  Like passing verification tests.
[25.000 --> 28.000]  In this example, it's able to pass capture forms.
[33.000 --> 37.000]  Or it can even automate tasks like picking up objects.
[45.000 --> 52.000]  Now, how it works is that each of these motors are all working together to complete a task.
[53.000 --> 55.000]  But there's more.
[55.000 --> 63.000]  This prototype can be controlled by hand gestures, which means we can have a more natural interaction when controlling the robot.
[63.000 --> 66.000]  We've been any part of the robot.
[66.000 --> 73.000]  And since it's wireless and portable, this means we can control it whether we're next to it or at a range.
[73.000 --> 77.000]  Completing tasks without the need to program every step.
[77.000 --> 81.000]  And this is going to be the first prototype for the project.
[81.000 --> 84.000]  And honestly, there's quite a bit we can do with this.
[84.000 --> 89.000]  And staying true to the Iron Man theme, we're calling this prototype Mark Wong.
[89.000 --> 94.000]  And in this video, we're going to find out how to build a robot arm, as well as a robotic glove.
[94.000 --> 98.000]  This video has been times damped so you can go to different sections.
[98.000 --> 105.000]  As well as you can find a 3D model, the code and the part list in the description below, which we're going to more detail.
[105.000 --> 111.000]  Before we start, if you like this type of content, help us be the YouTube algorithm by smash the like button.
[111.000 --> 113.000]  And also leave a comment.
[113.000 --> 117.000]  I literally reply to every comment, even if the comment is comment.
[117.000 --> 121.000]  Consider subscribing and turning post notifications on.
[121.000 --> 123.000]  We've got more videos on the way.
[123.000 --> 125.000]  Isn't that right, Mark?
[125.000 --> 127.000]  Mark?
[127.000 --> 137.000]  And if you stick to the end, you also find out how well this robot works.
[137.000 --> 139.000]  Anyways, that's not from me.
[139.000 --> 141.000]  And let's start building.
[147.000 --> 150.000]  The part list.
[150.000 --> 156.000]  Now, in order to put the robotic arm together, we'll need an Arduino.
[156.000 --> 160.000]  This will pretty much be the brains of the robotic arm.
[160.000 --> 162.000]  We also need six server mooses.
[162.000 --> 166.000]  The servers will be used as joints for the robotic arm.
[166.000 --> 170.000]  A stepper motor.
[170.000 --> 174.000]  A server driver.
[174.000 --> 179.000]  A battery for the server driver.
[179.000 --> 184.000]  A Bluetooth module to communicate with the robotic glove.
[184.000 --> 188.000]  Some jumper wires.
[188.000 --> 191.000]  And a breadboard.
[191.000 --> 195.000]  And for the robotic glove, what we'll need is an Arduino.
[195.000 --> 199.000]  This time we're using a smaller Arduino Nano.
[199.000 --> 202.000]  A breadboard.
[202.000 --> 206.000]  A flex sensor.
[206.000 --> 208.000]  And a cellarometer.
[208.000 --> 212.000]  Now these two will make up the sensors for the glove.
[213.000 --> 218.000]  And lastly, a Bluetooth module in order to communicate with the robotic arm.
[218.000 --> 222.000]  Links to the part sign in the description below.
[222.000 --> 226.000]  So, how does it work?
[226.000 --> 229.000]  Here's the drawings that make up the robotic arm.
[229.000 --> 233.000]  Now, we can think of the robotic arm as a series of motors,
[233.000 --> 238.000]  all working together to complete a task, like moving an object.
[239.000 --> 243.000]  Here's a closer look with each motor rotating on an axis.
[243.000 --> 247.000]  We use an Arduino to control the server motors.
[247.000 --> 251.000]  And to drive them all, we'll be using a driver.
[251.000 --> 256.000]  And each server motor would be programmed to move together to perform a task,
[256.000 --> 260.000]  like picking an object.
[260.000 --> 267.000]  And then we can assemble each server motor into a 3D printed robotic arm.
[269.000 --> 272.000]  And program it.
[272.000 --> 275.000]  And this is pretty much what we'll be building.
[275.000 --> 279.000]  But the question is, how do we communicate with the robotic arm,
[279.000 --> 282.000]  using hand gestures from the glove?
[282.000 --> 287.000]  So, when it's all stripped down, we've pretty much got a sender and a receiver.
[287.000 --> 293.000]  And we're using a sensor to send values to the robotic arm, to move the servers.
[293.000 --> 296.000]  And this is done over Bluetooth.
[297.000 --> 301.000]  So, having a closer look, we bend the sensor to the value changes.
[301.000 --> 306.000]  Now, if we exceed a specific value, we can send a message over the Bluetooth
[306.000 --> 309.000]  to turn that specific server motor.
[309.000 --> 314.000]  So, in that case, when we bend our finger, we can in turn control the robot's arm.
[314.000 --> 317.000]  We're also going to cover how the 3D arm is printed,
[317.000 --> 322.000]  and adding more flick sensors to make a complete robotic glove later on.
[322.000 --> 326.000]  But let's get back to the robot, and let's get started.
[326.000 --> 330.000]  Assembly of parts, the robotic arm.
[330.000 --> 333.000]  Now, there's different examples of robotic arms online.
[333.000 --> 336.000]  You can either buy one or 3D print one.
[336.000 --> 340.000]  But since I'll make another version, this one was 3D printed.
[340.000 --> 346.000]  And if you've got a 3D printer, you can find many good examples of 3 robotic arms to build.
[346.000 --> 351.000]  This is the one-hour model mine after, and credit goes to this maker.
[352.000 --> 358.000]  And you can find more instructions on the assembly, on the article in the description below.
[358.000 --> 366.000]  So, this robotic arm was slightly modified, so we can add a hole for an LED, for the grip a part of the motor.
[368.000 --> 372.000]  Now, 3D printing the robotic arm was pretty long.
[372.000 --> 376.000]  And if you want, you can get out of the box robotic arm instead.
[376.000 --> 381.000]  But, taking the 3D printing approach helps create custom parts like this.
[382.000 --> 385.000]  And we can print other parts.
[385.000 --> 392.000]  Now that they're all printed, we can now assemble it altogether, with the server motors.
[392.000 --> 397.000]  These can be simply screwed in using machine screws.
[397.000 --> 403.000]  And it will be mounted in just like this.
[403.000 --> 411.000]  And now we can slowly assemble the arm, with each of the 6 motors playing a part in the robotic arm build.
[411.000 --> 420.000]  And these are the parts that make up the robotic arm, once we fully assemble it.
[420.000 --> 432.000]  And here, we just assemble in the grip a part, slash claw, to the stem of the robotic arm.
[432.000 --> 445.000]  Now, the good thing about the robotic arm, is that it has ball bearings, so we can smoothly rotate left or right.
[445.000 --> 451.000]  The two main parts are the base rotation, and the robotic arm itself.
[451.000 --> 459.000]  And now that we almost assemble it, all we need to do is insert these two together, and lock it in place.
[459.000 --> 462.000]  And that's it for the assembly.
[462.000 --> 467.000]  Each of the 6 server motors have now been mounted in place.
[467.000 --> 476.000]  And each of these motors can now be programmed to move or perform a task, like picking an object.
[476.000 --> 486.000]  If you've got any other ideas, let me know in the comments below.
[487.000 --> 489.000]  Now the robotic arm is assembled.
[489.000 --> 496.000]  We can see the individual parts these motors play in the rotation and movement of the robotic arm.
[496.000 --> 505.000]  For example, we can rotate the shoulder joint, as well as extending the elbow joint.
[505.000 --> 513.000]  And we can even rotate the wrist joint, which will be the claw.
[513.000 --> 517.000]  Server motor wiring, introducing the Arduino.
[517.000 --> 522.000]  Now we have the server motors all assembled into the robotic arm.
[522.000 --> 525.000]  We'll still need to somehow power the server motors.
[525.000 --> 531.000]  And in order to power each individual server motor, we'll need a driver.
[531.000 --> 534.000]  And this is where the Arduino comes into the picture.
[534.000 --> 538.000]  Now, our doeners are open source, so there's different copies.
[539.000 --> 542.000]  We'll be also using a server driver.
[542.000 --> 547.000]  And the server driver will be using to do this, is the PCA 9685.
[547.000 --> 560.000]  And this is pretty much what we'll need to power the 6 server motors, which include jumper wires, a breadboard, and a 5.4 RC battery pack.
[560.000 --> 564.000]  Now we can slowly assemble these all together.
[564.000 --> 571.000]  Now, attaching the server motors is as simple as plugging them in into their color coded pins.
[574.000 --> 577.000]  Now we can add the other 5 in.
[579.000 --> 590.000]  And all of these all attach to the individual motors of the robotic arm, which can drive any individual server motor on the arm.
[591.000 --> 597.000]  And we can pretty much wired them all together, based on the diagram provided.
[600.000 --> 607.000]  And now we can add the 5 volt RC battery pack to the server driver to power the server motors.
[608.000 --> 611.000]  And we can do this by screwing these in.
[612.000 --> 623.000]  We can now hook up the Arduino to our laptop and load the code to power the server motors.
[624.000 --> 628.000]  And you can find all the codes in the description with each test code.
[633.000 --> 638.000]  In this example, we're just testing the server motors for the claw slash gripper.
[642.000 --> 647.000]  Now we have the 6 server motors working. We have one more thing to do.
[647.000 --> 653.000]  We still need to figure our way to make the robotic arm rotate left or right.
[655.000 --> 662.000]  Now the robotic arm is gaining a bit of weight. And using the standard server motor isn't powerful enough to move it.
[662.000 --> 669.000]  So instead of using the standard server motor, we're going to use a stepper motor, which is pretty accurate.
[670.000 --> 674.000]  As we can control the number of steps slash rotations needed.
[676.000 --> 681.000]  Now this is the diagram that shows the setup using the stepper motor and the driver.
[683.000 --> 689.000]  The stepper motor comes with its own driver, being the A4988 driver.
[692.000 --> 696.000]  And now based on the diagram, we're just going to assemble it all together.
[700.000 --> 706.000]  The stepper motor requires a higher voltage compared to a server motor.
[706.000 --> 711.000]  So we're going to use a 11.1V Li-Po battery to supply the power.
[713.000 --> 717.000]  And loading the test code, we can see it rotate clockwise.
[717.000 --> 722.000]  We can even smoothen the stepper motor movements by adding a capacitor.
[723.000 --> 725.000]  So an overview.
[725.000 --> 729.000]  We went from adding the six server motors to adding the stepper motor.
[729.000 --> 734.000]  And now this is the four robotic arm electronic diagram.
[736.000 --> 742.000]  And now we're happy with it. We can mount the stepper motor into the base of the robotic arm.
[745.000 --> 748.000]  Which we can line up and eventually screw in.
[749.000 --> 755.000]  The stepper motor will be mounted to a gear tooth, which would in turn rotate the whole robotic arm.
[755.000 --> 761.000]  And as you can see, we've got the smaller gear tooth and the larger one in the back.
[761.000 --> 766.000]  And we can place these two in and they're locked in place.
[767.000 --> 778.000]  You can also see that the ball bearings provide for a smoother contact, also reducing the noise.
[785.000 --> 788.000]  And now we've got the robotic arm all assembled.
[788.000 --> 792.000]  We can load in the test code to rotate the robotic arm.
[792.000 --> 795.000]  And that's pretty much it for the robotic arm.
[796.000 --> 801.000]  And if it's the robotic arm you wanted to do, you can pretty much stop here.
[801.000 --> 804.000]  The next part will be on how the glove is assembled.
[804.000 --> 808.000]  Assembly of parts, the robotic glove.
[810.000 --> 812.000]  Now stay in true to the aesthetics.
[812.000 --> 815.000]  The robotic glove was also 3D printed.
[815.000 --> 821.000]  But you can use a standard glove to work with, which I used with earlier versions.
[821.000 --> 826.000]  Now the glove comes in parts which can be printed off individually.
[826.000 --> 834.000]  In this example, I'm printing off the index finger of the robotic glove, which comes in 3 segments.
[834.000 --> 839.000]  The 3 parts representing the finger joints can all be snapped in.
[839.000 --> 844.000]  I want saw assembled if fits perfectly on my finger.
[844.000 --> 848.000]  And there we have it, that's the finger joint.
[849.000 --> 852.000]  And this is how it looks when it's all assembled.
[855.000 --> 859.000]  Now the glove provides a good degree of freedom, which is a bonus.
[859.000 --> 864.000]  So now that's done, let's find out how the robotic glove senses work.
[865.000 --> 868.000]  And from the part list, we'll need an Arduino Nano.
[868.000 --> 872.000]  This will be ideal since it's small enough to fit on our hand.
[874.000 --> 877.000]  Also a breadboard for prototyping.
[877.000 --> 882.000]  And then a solarometer to measure the changes in the hand movement.
[882.000 --> 884.000]  And some jumper wires.
[887.000 --> 889.000]  And the flex sensor.
[889.000 --> 893.000]  These two types of sensors would be the main focus.
[893.000 --> 898.000]  And lastly, a 10kW resistor for the flex sensor.
[899.000 --> 903.000]  To start off, the following wiring would focus on the flex sensors.
[903.000 --> 908.000]  With the output of the flex sensor, going to analog 3 on the Arduino.
[908.000 --> 915.000]  And once that's wired up and the code has been uploaded, which you can find in the description, we can test it out.
[916.000 --> 920.000]  Now the flex sensor works a bit like a potential divider.
[920.000 --> 923.000]  And as the flex sensor bends, the resistance changes.
[923.000 --> 927.000]  And here's a graphical look of the flex sensor value changing.
[927.000 --> 930.000]  Now put in a threshold that let's say 70.
[930.000 --> 937.000]  If it passes this, we'll send a value to the robotic arms Arduino through Bluetooth.
[937.000 --> 943.000]  And by holding the flex in place, we can also hold the position of the server motor.
[943.000 --> 946.000]  And in turn, the robot.
[949.000 --> 954.000]  And by taking this idea and attaching it to our finger, there we have it.
[954.000 --> 957.000]  We have a sensor that can detect the changes in our finger movement.
[958.000 --> 963.000]  Now, the accelerometer would be used to measure the changes in our hand movement.
[963.000 --> 969.000]  And this is the diagram with the updated accelerometer in place.
[969.000 --> 975.000]  And now we can upload the accelerometer test code.
[976.000 --> 984.000]  And by moving it slightly, we can see how the X and Y coordinates change based on the relative position of the accelerometer.
[984.000 --> 987.000]  Moving left to right, up and down.
[990.000 --> 994.000]  And that's pretty much it what we'll need and how it's assembled.
[995.000 --> 1001.000]  With the two sensors alone, we can control the robotic arms gripper to open and close.
[1002.000 --> 1010.000]  And as well as rotating the gripper counterclockwise or clockwise, as well as up and down.
[1011.000 --> 1016.000]  Now this idea will form the basis of the 3D glove.
[1016.000 --> 1025.000]  And for this, I pretty much added two extra flex sensors and another accelerometer, which can be powered from a 9 volt battery.
[1027.000 --> 1031.000]  Adding additional sensors, this is what the electronics looks like.
[1031.000 --> 1036.000]  With a Bluetooth module to communicate with the robotic arm.
[1037.000 --> 1042.000]  Now the next step is attaching electronics to the robotic glove.
[1042.000 --> 1045.000]  Going from this to this.
[1047.000 --> 1051.000]  Where we can bend the flex sensors, which are mapped to each finger.
[1053.000 --> 1058.000]  And the most important thing about the assembly is securing all sensors in place.
[1058.000 --> 1065.000]  And to do this, we can use hot glue.
[1067.000 --> 1071.000]  And this is how we're going to wear the glove.
[1073.000 --> 1082.000]  Given that all sensors are now being added, we can now go into more detail on how every flex sensor maps onto the arm.
[1083.000 --> 1089.000]  You can see how each sensor represents a servo on the robotic arm.
[1091.000 --> 1096.000]  Now this is optional, but you can even add the second accelerometer to an arm band.
[1096.000 --> 1101.000]  As well as a 9 volt battery, which was added to make the robotic glove portable.
[1103.000 --> 1107.000]  And this is pretty much the robotic arm prototype on a breadboard.
[1107.000 --> 1110.000]  We'll see how we can make this more advanced.
[1113.000 --> 1123.000]  Now believe it or not, the robotic glove required me to isolate some of my joint movements to not trigger any false positives.
[1123.000 --> 1127.000]  And this is where body isolation became useful.
[1129.000 --> 1131.000]  Here it is all assembled.
[1133.000 --> 1135.000]  And finally, the build.
[1135.000 --> 1137.000]  This is what each part does.
[1138.000 --> 1143.000]  So opening and closing the robotic claw can be done by moving our index finger up or down.
[1144.000 --> 1150.000]  And rotating counterclockwise or clockwise will move the grip ahead as well as up and down.
[1151.000 --> 1158.000]  And we can rotate the whole robotic arm left or right or bend or stretch to move the robotic elbow.
[1161.000 --> 1164.000]  Now that is the robotic glove and arm pretty much done.
[1165.000 --> 1169.000]  Now let's get back to the coat to see how the programming really works.
[1173.000 --> 1179.000]  Now the programming part is explained in more detail on the article in the description below.
[1179.000 --> 1182.000]  But it's still important to go over the key parts.
[1183.000 --> 1191.000]  Ideally there are two main coats, one for the robot arm and the other for the glove, being the controller in this case.
[1192.000 --> 1197.000]  So let's start off with the robot arm and see how this will be programmed.
[1197.000 --> 1204.000]  To start off, the robot arm includes the server driver library, being the PC9685.
[1204.000 --> 1209.000]  This way we can power multiple servers, all controlled by an Arduino.
[1209.000 --> 1213.000]  This will be used rather than using the standard server.right function.
[1214.000 --> 1219.000]  The following here declares and initializes the variables for the step-amotor.
[1221.000 --> 1227.000]  And in the setup we can declare the pins used for the server and step-amotor.
[1228.000 --> 1236.000]  In the loop section, I've added a delay of three seconds on start up, so the robot doesn't jump at you straight away.
[1236.000 --> 1243.000]  Now the way we control the server motors is by using the library name dot server.
[1243.000 --> 1250.000]  This takes two parameters, the position of the server plugged on the driver, starting from zero.
[1251.000 --> 1254.000]  And the position will like to move it.
[1254.000 --> 1261.000]  In this case we'll be moving the server on channel three to the relative position of ten.
[1261.000 --> 1270.000]  Now with that theory we can pretty much make a function that can move the wrist part of the robot arm as seen here.
[1270.000 --> 1278.000]  And from there you can make other functions like opening and closing the claw and making the robot stand.
[1279.000 --> 1283.000]  And that's pretty much it for the robotic arm alone.
[1283.000 --> 1291.000]  But if you would like to take one step further and control the robotic arm with the robot glove, here's the code.
[1291.000 --> 1299.000]  Now for the robotic glove, as mentioned we have three flex sensors and two accelerometers and these are initialized here.
[1299.000 --> 1306.000]  We'll first off declare the three sensors on the thumb, pinky and middle, as well as the accelerators.
[1306.000 --> 1316.000]  In the setup, we'll begin the transmission of the sensors, including the Bluetooth serial communication at the board rate of 4800.
[1316.000 --> 1323.000]  Now in the loop section, we'll read the values of the flex sensors to the Arduino.
[1323.000 --> 1333.000]  And based on the previous theory, when the value of the flex sensor bends exceeds the threshold, this is when we'll send the character F.
[1334.000 --> 1339.000]  And this value is what will be sent through Bluetooth to the robotic arm.
[1339.000 --> 1349.000]  And if we go back to the robotic arm code, we can create a function that listens on the board rate of 4800 with the Bluetooth module.
[1349.000 --> 1359.000]  And if it receives the character F, this would then call on the GRIPER SERVER backward function, which will move the server.
[1359.000 --> 1366.000]  And this is an indefinite loop, always waiting for communication from the glove to the robotic arm.
[1366.000 --> 1374.000]  And we have an example function here, whereby we're moving the server on the 5th channel of the server driver.
[1374.000 --> 1378.000]  And we can create as many functions here.
[1378.000 --> 1385.000]  And that's pretty much it for the programming. It's now time to put everything all together.
[1389.000 --> 1399.000]  Now putting it together, a 3D printing enclosure was used in case the circuitry of the robotic arm, as well as some braided cables for protection.
[1399.000 --> 1405.000]  And now we can finally place all our circuitry into the enclosure.
[1405.000 --> 1411.000]  And we can use a simple power bank to power our Arduino.
[1411.000 --> 1419.000]  And this is it. This is absolutely everything we'll need in terms of hardware to work with this robotic arm prototype.
[1419.000 --> 1423.000]  Now let's test it out.
[1423.000 --> 1429.000]  In this example, we have the robotic arm waking up.
[1429.000 --> 1434.000]  And we can just pretty much close the enclosure, which has a snap on the lid.
[1434.000 --> 1438.000]  And now it's program. It's now time to test it out.
[1438.000 --> 1445.000]  And if we bend the flick sensor, the value changes. And this is sent to the robotic arm.
[1445.000 --> 1449.000]  So how old does the robot arm respond to hand gestures?
[1449.000 --> 1453.000]  Well, the prototype is pretty responsive and works.
[1453.000 --> 1459.000]  However, the robot glove is pretty sensitive, as it had quite a few sensors.
[1459.000 --> 1466.000]  Plus, it was a bit of a learning curve to control the robot without triggering other parts of the arm.
[1466.000 --> 1475.000]  But the good thing is these are programming related. And improving the code should improve the accuracy and the fluidity of the arm.
[1475.000 --> 1482.000]  We'll revise this prototype sometime in the future. And I'll probably call it Mark II.
[1482.000 --> 1485.000]  Hey, you've made it to the end, or you skipped ahead.
[1485.000 --> 1487.000]  Either way, thanks for watching.
[1487.000 --> 1491.000]  By the way, I've also recently started a Patreon.
[1491.000 --> 1496.000]  And if you would like to support the projects, that's the best way to do it.
[1496.000 --> 1503.000]  So thanks for that. And thank you for all the subscribers. I really do appreciate it. Honesty is crazy.
[1503.000 --> 1509.000]  And thank you to everybody who subscribed. I literally reply to every comment. So please let me know if you do have any questions.
[1509.000 --> 1516.000]  And if you want to make a project like this and you want to improve on the code, definitely contribute to the Git repo.
[1516.000 --> 1519.000]  And you can find more details in the article below.
[1519.000 --> 1523.000]  I'm Evan. Thanks for watching. Peace.