Robotics 101 - Electronics & Mechanics Basics - Ep. 1

[00:00:00]Hi, my name is Milos and welcome to element 14 robotics 101. This is a four-part series where I will teach you everything you need to know how to design, make, and program your very first robot. Let's talk robotics.

[00:00:16]>> [music] >> Welcome to robotics 101, a place where we're going to find out what makes these guys tick and how we can actually make them on our own. It will be a four-part series where we're going to cover everything from uh mechanical stuff, electronics, control engineering, to making our mobile robot platform and our robot arm. But before we get to that, let's answer one simple question. What is even a robot?

[00:00:43]So when we see a robot, we think of an electromechanical system that fulfills some task and interacts with the environment. These interactions can go two ways. From the environment to the robot, this is the case where we use sensors on the robot to measure those interactions. This can be temperature, light, wind speed sensors. Sensors are components that transform environmental factors into electrical signals that we can read using our electronics. On the other hand, the robot can interact with and influence the environment it is in.

[00:01:10]It does this through actuators. Imagine a small gripper on a robot moving stuff around. Some common examples of robots would be things like delivery robots which drive around delivering packages.

[00:01:20]They have motors in their wheels to drive and a bunch of sensors like cameras and distance sensors to make sure they don't crash into things.

[00:01:27]Another example would be a robot arm.

[00:01:29]This here is called a SCARA configuration, but we will talk more about robot arm configurations in a later part of this series. These kind of robots are in factories all around the world.

[00:01:39]We can continue listing different types and configurations of robots for hours like this. Generally, the robot we need is highly dependent on the type of task we want it to complete. For this course, we will focus on two broad categories and make an example from each of them.

[00:01:53]These are the categories that you already seen with the first one being robot arms. These are in factories all around the world as I've mentioned.

[00:02:00]They're great for picking place operations and repetitive tasks. We will go much more into detail in the fourth video of this series where the whole video will be dedicated to robot arms.

[00:02:09]The other type we will focus on will be mobile robot platforms. These are your delivery robots, vacuum cleaner robots, anything that moves around really. Video three of this series will be completely dedicated to this category where we will explore making our own and also doing a lot of cool algorithms.

[00:02:25]From here, uh there are mixes of these two where you can have a robot arm on a moving platform, different configurations of robots such as humanoids, quadruped robots, and so on.

[00:02:35]There is also a whole category called soft robotics, which are robots made out of soft materials like silicone rubber which bend like octopus arms and have a different style of actuators like pneumatic or tendon actuators. So, there are a bunch more types of robots, but we will focus on these two for now.

[00:02:53]>> [music] >> The list of robots goes on and on and it will expand as new robots are made, but we will focus on two categories here, the robot arms and the mobile robot platforms, and we're going to make both uh in this course. So, uh to follow along with this course, you can of course use a 3D printer, but my idea is also for you to be able to recreate this course just using some cardboard and hot glue gun. Uh for all of the other parts, the electronics and everything else, you'll be able to find them uh linked all below, but for this first part of the video, we're going to cover mechanics, we're going to cover 3D printing, and we're going to cover electronics. To tie it all together nicely, let's begin with the electronics.

[00:03:40]To explain the electronics, I will use the robots in my hands as examples so that you can understand the concepts. In my right hand, I'm holding Perry the Platypus Bot, a mobile robot platform, and in my left hand I'm holding a small robot arm. Let's begin with the arm.

[00:03:54]These markings in yellow represent the joints of this robot arm. Each of these joints is actuated by a servo motor, and the joints are connected by segments. A servo motor is a small actuator that is incredibly easy to use. We need to power it up, and we need to send it an angle command. The electronics inside it do the rest. While this can be limiting in some cases, since we can't control things like speed of the motor, it's a really nice and easy way to make a robot arm and experiment with robotics. To send a signal to the servo motors, we would use a microcontroller.

[00:04:25]Now, let's take a look at the small mobile robot. These are actuated wheels, and this type of robot has a differential or tank drive. This means that we control the robot by varying the speed between the two wheels. These motors come with encoders, which are a type of sensor used to measure rotational angles and speeds. We will experiment with them in this series later on. We also need a way to power the robot, and in this case, this is done using a battery. To tie it all together, there is a microcontroller which acts as a brain of the whole robot. To get an idea of what you need to make your first robot, let's summarize the electronics from these two. First, we need some kind of a power supply to power the whole robot. This can be something as simple as a battery.

[00:05:04]We then need a brain for a robot. In our case, this would be a microcontroller. A robot can have sensors like the wheel position sensors on our mobile robot platform, and we need actuators. For that, we will use motors with motor drivers, since microcontrollers are not powerful enough to drive motors directly from their pins. For the arm, on the other hand, in the case of the servo motors, the motor driver is integrated into the actuator itself, so we don't need an additional motor driver. While the electronics are incredibly important, we won't go too much into detail there, because our goal is to just make two simple robots, so we will use modules. Uh still, we need to know the basics, and as you've seen in the drawing, there are a few things we need to cover. First, we need to power the robot somehow. It can be as simple as a 9-V battery or even a battery from a power drill like this one. This is what I've used for my previous robot and it worked great. Then, for the robot to actually be smart to do something, it needs to have some kind of a brain. For that, we're going to use a microcontroller. Uh this is an example of that. This is an Arduino Uno. Uh we will use uh one by a different manufacturer, but any will work. So, what do we do with this? We actually program it. Uh we put our algorithms on it uh so it can actually control the robot. But, what does it mean to control the robot? It means it interacts with the environment uh if you remember. So, we need sensors and actuators for that.

[00:06:24]Uh for example, here is a small sensor that we can connect directly to this microcontroller and read the data off of it. And we also have actuators, but uh this is one thing that you need to know.

[00:06:36]We can't control a motor directly uh from the microcontroller. There needs to be some kind of electronics in between like this motor driver, and you will get the hang of it uh along the way. To begin, let's do some simple electronics demos on the bench and then to slowly [snorts] incorporate that into robotics.

[00:06:58]Now, we're at the bench and we're going to discuss sensors. When we say sensor, you can imagine things like this. This is an IMU and measures your angular velocity and accelerations, and it's a really useful sensor when trying to control something in the air like a drone, for example. But, we're going to go much simpler just so you can get the concepts, and we're going to use a simple potentiometer. This is actually a rather nice sensor. If you get the linear potentiometer, uh what that means is that there is a linear characteristic between the angle of the knob of the potentiometer and the actual change change in resistance. How do we actually connect a potentiometer?

[00:07:35]We're going to use a breadboard, and we need power, and we need a signal pin.

[00:07:40]Let me connect that real quick.

[00:07:45]Okay, and now we have our potential meter connected to our voltmeter. And now you can see that when we turn the potential meter, you can see that the voltage changes and it's going to change from 0 volts to 3.3 volts since our power supply for the potential meter is 3.3 volts.

[00:08:04]Now, let's take another wire and connect our microcontroller to it.

[00:08:09]Should be here.

[00:08:11]Now, if we switch to the screen, you can see a simple sketch that I've written in Arduino IDE for actually measuring the value from the potential meter. If this is your first time in Arduino IDE, it's rather simple and I'll explain. You have two functions that you always need to have. That's the setup function and that's the loop function. The setup function runs only once at the beginning of the power on and the loop function runs continuously after that. All we do here is start our serial monitor, our serial communication, which is the communication between the PC and the microcontroller, and we set the resolution for our ADC on our microcontroller. After that, all we do is actually read that value and just delay it by 20 milliseconds. Now, if you go to the serial monitor and check it out like so, you can see that the values change as we turn the potential meter.

[00:09:07]But, you might see a difference here and that's on the serial monitor, we get values so from around 0 to 4095, while on the multimeter, if you take a look, we go from 0 to 3.3 volts. If you remember, we've set the resolution here to 12 bits and this is how that corresponds. But, we can also measure the voltage if we add a line of code.

[00:09:32]Let's do that real quick.

[00:09:34]>> [music] >> And now we upload the sketch.

[00:09:42]>> [music] >> Now if we take a look again and we compare the values from the multimeter and our Pico, you can see that they are rather close. So this is around zero and if we go to let's say this is should be 1.6. Yeah, you can see that it's around 1.6 and so on. Uh this is how we're actually measuring the voltage and that's a fully working sensor circuit. You might be thinking this is rather simple, but uh if you remember the servo motors that you've seen in the robot arms, they actually use a potentiometer just like this to measure the angle of the output shaft and that's how they internally work. Now let's switch up switch it up and actually use one of those servo motors so you can see how it is how easy it is to control one of them.

[00:10:29]>> [music] >> You've just seen a few sensor demos with sensors like this one here and now it's time to switch to actuators. The actuator we're going to use is a servo motor. If you remember from before, I said that we can't just connect a motor directly to the Arduino even though you can see that these wires look like we can and here's the thing. This isn't just a motor. Inside this thing here, we have a whole electronics board, the motor driver, with some sensory circuit that we won't get into now that can actually control this motor so we can actually connect this directly to the Arduino. Let's program the Arduino to control a servo motor. Let's see how that works and then we're going to close the loop.

[00:11:08]Here is the actuator that we will be using. So this is just a simple servo motor and I've attached to this horn so we can more easily see how it moves. If you listen closely, you can hear a bunch of gears turning inside and we'll check out what's happening with that later in this video and we have three wires. So if you take a look at the the here, the brown wire is ground, the red wire is 5 volts, and the yellowish wire is the signal wire. So, that signal wire we're just sending it a PWM signal of a certain duty cycle. We will discuss that in the fourth video in more detail, but all you need to know is that this microcontroller will send a signal through a single wire, and it will set an angle for this. So, let's connect it right up.

[00:12:00]And now, if we connect this wire here, you will see the actuator moving.

[00:12:08]If we switch to the code real quick, uh you will see the whole code. So, we're using a servo library, though it's not working the best with this microcontroller, but we will do our custom integration of it in the last video of this series. You can see that we're just sending it a PWM signal of a certain pulse width. So, from 800 to 2,500 microseconds, and just ramping it up, and then ramping it down.

[00:12:35]And that's how why we see the motor moving like this.

[00:12:38]And if I try to actually hold it in place, uh it's actually having some uh torque behind it.

[00:12:47]But now, uh this actuator is working great because there is a sensor inside, but let's see what the actual what it actually means to close the loop.

[00:12:58]We've seen our both sensors and actuators, and now it's time to close the loop. What does that actually mean?

[00:13:04]This is the whole essence of robotics and general electromechanical systems in industrial electronics and everywhere else. Uh the idea is if we have some kind of a sensor measurement, we measure that so using a microcontroller or a PLC as you've seen in the previous test.

[00:13:20]What we want to do is use those sensor measurements, uh run them through some kind of an algorithm, and then based on that control our actuator. That means closing the loop. So, we close the loop from the measurement to the actual actuator. Let's see how this looks in practice by us controlling this servo motor using our potentiometer. Now, it's time to close the loop. So, what that means is using this sensor, uh getting those measurements, doing something with them, and sending that data then over to the actuator. Why is that called closing the loop? Because we have a full control loop. So, we're using the measurements from this sensor to actually uh interface with this actuator through the micro control. If we power on the servo motor like so, you can see that as I turn the servo motor, you can see that if I turn the potentiometer, you can see the servo motor moving. So, that's what a sensor means closing the loop. Now, this may seem like a rather simple example, and [snorts] if we take a look at the code now, you can see that the code is really really simple, where we just send a single command through like microseconds by simply dividing the analog read with two and adding 800 to it. And you can see that we can actually control the servo with this, and it's actually giving us some pushback, so it's keeping the position.

[00:14:41]While this seems rather simple, it's the same principle for everything. If you look at the IMU and for example this little drone here, it's the same thing.

[00:14:50]It has an IMU, and using those measurements, it closes the loop. Yeah, I actually closes to loop three loops for each of the three axes, and controls these four these four motors based on that loop. So, that's pretty much how all of the electronics and robotic system work. The thing is, this is just a simple example, so you can see how it works, but if we take for example two of these or maybe five potentiometers, we can make what's called a a of the robot arm, and just by moving that robot arm around that's made out of potentiometers, we can control a whole robot arm that's made out of servo motors.

[00:15:29]>> [music] >> We're going to get into control engineering and programming in the next video of this series, but for now we're going to switch our focus from electronics to mechanics. We won't go too deep into mechanics here like joint angles, kinematic, stuff like that because they're specific to a robot and we will cover that as we make our robots. We're going to cover some basics here, something that is applicable to both of the robots that we're going to make and that's gearboxes. What's a gearbox? You've heard that term used in association with cars for example, but here if you take a look we have an electric motor and here's an actuator that I've shown you. Here this part here is a electric motor and this here is a gearbox. Why do we even need that? The same thing can be seen here.

[00:16:16]The motor itself is just a small part of this whole thing. So, let's take this thing apart, see what's a gearbox, see what it does, and we'll take it from there.

[00:16:29]Time to take apart this servo motor and see what's actually going on inside.

[00:16:33]Let's begin by taking off this servo horn.

[00:16:37]And removing the four screws on the bottom.

[00:16:41]>> [music] >> Now if we take off this lid and this here, let's take a look.

[00:16:53]Okay, so this thing you see here is the actual motor. Well, here is the motor driver that I talked about. And as you can see this is all pretty much just empty space. So, this motor driver here uses underneath this gear.

[00:17:07]You can see actually a small potentiometer just like you've seen in the in our demos. So, this potentiometer actually measures the angle of the output shaft and using that it controls this motor. But besides that, we have a bunch of small gears here. Uh what these gears gears do actually is uh reduce the speed of the motor and increase the torque substantially. So, these small motors are great for spinning fast, but they're not uh really talky. And as you've seen with the servo motor, what we actually want is small movements, so like 180° or 90°, and we don't need it to be too fast, but we want it to be as strong as possible. And that's what we're actually accomplishing with the gears. How that's all calculated, you'll see in one of the next clips, but for now I just wanted to let you know that most of the actuators that you're going to use in robotics are going to have some kind of gearbox.

[00:18:06]Uh for the end of this clip, let's take a look at actually putting everything together through CAD and 3D printing.

[00:18:16]We've covered all of the essential parts for electronics and mechanics to build our first robots, but now we need to figure out how are we actually going to make them. If you take a look at this robot here, it's mostly 3D printed because in the last few years the 3D printers have become really really accessible, so this is what I'm going to use. But also since I know that not everyone has an access to a 3D printer, all of the robots will be simple enough that you can make them using some hot glue and uh some cardboard. But uh to cover all of the stuff, we're let's take a look at what's actually CAD. How do we go from an idea to actually holding something in our hands, and how does the whole 3D printing pipeline work? Let's begin with the term CAD. It stands for computer-aided design. These are the software packages you use to create your 3D models. If you're experienced with 3D modeling or printing, these will be things you know, but if you are new, I will try try explain everything intuitively.

[00:19:12]I'll start by talking about something that everyone knows, drawing on a piece of paper. At its simplest, you can imagine 3D modeling as extracting your drawings from that piece of paper into 3D space. Let's begin with the simplest shape, a cube, and let's say that each side of the cube is 10 mm. To model this cube, we first need to begin with a 2D sketch. Our sketch to model this cube would be one of its sides, a square, and we would set the edges to be 10 mm, of course. After our sketch is complete, we want to pull it out of the paper, and that's called extrude. If we extrude this square by 10 mm, we will get our cube. We can do sketches in any plane or a flat surface, and what I'm describing now is just one of the simplest tools, but one which will allow you to create a lot of things. The best way to go about learning this is by trying one of the many free tools online. Some great options are Tinkercad, Fusion 360, Onshape, and FreeCAD. There, you can experiment with designing your own 3D models. If you would like to go more into organic modeling, then you would use something like Blender.

[00:20:09]Let's talk about 3D printing now. There are various types of 3D printing technologies. The one we will focus on is the FFF, which stands for fused filament fabrication. This is the most widespread technology, and these are the printers that you see all around with spools of plastic filament in the back.

[00:20:24]These 3D printers work by moving the nozzle around, which melts and deposits the plastic precisely where it's needed.

[00:20:31]For the printer to actually know where to and how much plastic to melt, we need to first slice our model. Slicing is a process in which we take the model we have designed in our uh CAD software and convert it into a file that our 3D printer understands. We do this in a program called slicer, no surprises there. Here's how a typical slicer works. Let's take our cube from before and slice it. We will end up with something that looks like this. These lines that you can see on the side are layer lines. The printer works in layer-by-layer mode, uh where it first finishes one layer, then it jumps to the layer above, and so on. Our slicer uh slices our model into these layers, and also generates the path for our nozzle for each of those layers. Here's an example of how a bottom layer path would look for our cube. The principle is the same as if you were to take a pen and try coloring in a square on a piece of paper. The nozzle would usually start with the outer edges depositing the plastic there, then it would move inwards and slowly fill in everything with plastic. Once it has completed that layer, the printer would move up to the next layer and do the next layer on top of the previous one. The plastic coming out of the nozzle is hot enough to bond with the layer below it and this is why we get a solid 3D print in the end.

[00:21:41]There are a lot of tiny details left out here, of course, but this is just so you could get an idea of how the whole process works. Let's see how all of this would look in practice. If this is your first time 3D printing or CAD modeling, I'll show you all of the things that you've just seen in the drawing step-by-step. So, first we're now in Fusion 360, which is the CAD software of my choice, and this is what you get when you open a new project. So, it's just an empty space. Uh with this click here, we create a sketch and that's the 2D sketch that we talked about. And we choose a plane, for example, this.

[00:22:13]Now, in the top left that you can see here, you can find a lot of different tools. So, you have your circles, you have your rectangles, different kinds of lines.

[00:22:24]So, the best way to actually try is to try this and experiment yourself. I'm just going to show you a simple way to do this. We'll take this, which is a center rectangle. We choose the point where we want it, so like this. And now we can enter the dimensions we want. So, let's say for example, we want 20 mm, then you press tab by 20 mm.

[00:22:46]And you get yourself a square. You can, of course, always double click and change this to 25 or any other dimension and so on. But, this is just a short little demo so you can see how the whole process looks like. But, once you're done with that, you can click finish sketch, and if you hold shift and your mouse button, you can now look at it in [clears throat] 3D space. Now, if you remember from the drawing, we want to extrude this into 3D space, and we actually do that with extrude. That's how the command is called, and we extrude it by 20 mm, and that's how we get ourselves a cube. If you hold your mouse over any of these functions, you can get a detailed explanation on how they work and what they actually do, which is really useful if this is your first time doing something with CAD. And that's pretty much your first 3D model. From there, if you go here to bodies, you can see that your cube is here, and by clicking right click and save as mesh, you can save your model so you can open it later in the slicer. Let's look at that part now.

[00:23:50]This is a Creality Print, which is the slicer that is configured for my K1C 3D printer, and here I have the same cube that we've just designed loaded up. So, if we click slice plate, we will get something like this. If you remember from the drawing, you can see that here you can see all of those individual lines, and a really cool feature here is that you can see how the print looks inside. And here are some interesting details that we may may have mentioned.

[00:24:19]You have You can see all of the infill, you can see the outer walls, and we can adjust all of those parameters. For example, if you go to strength, and let's say we want four wall loops, and click slice, you can see that the walls are thicker if you want the part strong. Maybe we want more infill or or a different kind of infill. We can choose that here. For example, let's say gyroid.

[00:24:43]Click slice, and you can see that the infill inside looks completely different. So, there's a lot of settings here that you can play around with. Some are for strength, some are for support materials, and so on. And this may seem like, "Oh, is too simple, but using these principles literally and just some of the other tools, you get to more complex module module, sorry, models like this here. So, this is the robot arm on a mobile robot platform that you've just seen. Or for example, Perry the platypus bot here.

[00:25:15]It's exactly the same principle with creating a sketch, extruding it, or doing revolve, some of those functions that you can see up here and just literally using it as a puzzle and just going from there. And in the end, you get to complex assemblies like this and you can make your own robots.

[00:25:34]And that would be it for the first part of this video series where we've covered what's a robot, how do they work. We've covered the basics of electronics, mechanics. We've seen how a 3D printer works. And for the next video in the series, we're going to cover control engineering. We're going to talk about PID controllers, we're going to talk about control loops more. We're going to go into programming a bit more and then in videos three and four, we're going to make a robot arm and we're going to make a small mobile robot platform. You're going to have a lot of additional resources linked down below. Also, if you have any questions or comments, please leave them down below and I'll be happy to apply to them. So, get ready for the next video since we're going to go and make ourselves two robots.

[00:26:19]>> [music]