Five Servo Balancing Bipedal Robot

Hinzugefügt: 2026-05-26

[00:00:00]This is the third in a series of designs that you can build. All of my projects are actually open source, but most people don't actually build the things like the ball wheeled bikes. So, I'm doing a series of smaller, more accessible projects. The first one was a mini robot dog, which you can find in my channel, and last time I built a hexopod. So, we've done four legs and six legs, and now I thought I'd have a go at two legs. This project is a little more experimental, and I've set two requirements for myself. Firstly, I want it to actively balance as it walks. So, no big flat feet. And secondly, for that reason, it needs to pick its feet up properly as it takes steps. So, no shuffling along the ground like a cheap toy. Also, I want this to be accessible for other people to be able to build and experiment with. So, I'm using standard RC style servos and an ESP32 again, which are easily available. All of the CAT and code is free and it's open source on my GitHub, but I also have enhanced downloads for patrons which include useful things like a wiring diagram, a list of all the parts, including nuts and bolts, and written documentation about the build and the code. But the designs are still open source, so there's nothing to stop you making kits and selling them or commercializing the designs somehow, which is totally fine, just like Rep 3D printers, the Linux operating system, or Arduino clones. If you do want to do something commercial with it, then it would be nice if you could support me on Patreon if you wish. But you don't have to cuz it's still open source. There are just five servos in this design, which is less than half the 10 or 12 actuators you'd normally find in a bipedal robot.

[00:01:33]I'm publishing solid models for this project in step or STP format, which I actually do for every project. These are far superior to STL files cuz you can load the project into your own CAD software and edit it as if it was your own project. So, it's really easy to pull the surfaces in and out or change it completely. It's worth mentioning that this project is supposed to be easy to understand and experiment with. So, although it could probably be made to work better if I trained the robot with AI or reinforcement learning, that's totally out of scope for this project.

[00:02:04]Check out Scientific on YouTube if you want to see a really good bipeedal robot that was trained in Nvidia Isaac Lab.

[00:02:10]The whole thing took over a year to get working though, and a lot of that was making the simulation work on the real robot. Also, check out Kaden Nappic, who recreated one of Disney's Star Wars robots. This also appears to have been quite involved with similar issues getting the simulation to work on the real robot. I've actually built quite a few bipedal robots in the past, but lots of those were highly experimental, and I don't recommend trying to recreate them.

[00:02:35]I did previously build something similar to the project in this video, which looked promising until it fell down and broke. The servos in that project were Dynamixels, though, which were given to me by Robotus, and those servos are around £400 in money to buy each, so that's really out of reach for most people. Let's see if we can make something similar on a budget, though.

[00:02:58]Thanks to Prusser Research for sending me some 3D printers for my 3D print farm. I've got some core 1 pluses and some core 1 L's. So, it's quite important the mass distribution is correct for this project as it turns out. So, these sticks have four perimeters and a 20% infill. And they're all printed with a 0.4 mm nozzle. The other parts have just two perimeters and a 20% infill. And again, are printed with a 0.4 mm nozzle. And that's the density that you can see there. I printed these parts this way up with support material underneath so that my round joints are properly round and those aren't supported underneath by support material. Here's one of the dynamixels I used in the previous project which you can see is quite chunky. It's 100 kg cm. And here is a standard RC servo which is 25 kg cm of torque. These servos have metal gears and they are provided with metal servo horns and they are MS62 digital servos which are quite easy to find. I think that's the metal servo horn so I didn't have to buy them separately this time.

[00:04:00]According to the spec they run on 8.4 volts which is really important and use quite a lot of current. They are also 270° servos. So that means they can rotate all the way round which is far more than normal servos. And this is quite important, otherwise all the kinematics will break. I had to pull the rubber grommets off cuz they're quite chunky and otherwise the servo won't fit in my print. So there's a slot in there. The cable goes down and obviously the grommet restricts that. And if you make the hole bigger, then the screws won't go in. So these are just attached with some normal selftapping screws. And I've also got some metal rods which are going to be the only other real hardware part for some of the joints. So these I've just cut down with a hacksaw. These are stainless steel in 4 mm diameter.

[00:04:47]And I just deburred the edges on a file by rubbing the rod on the file cuz it's much easier than doing it the other way round.

[00:04:54]There are two stainless steel rods pushed through the feet and those are just a push fit. But of course, you've got solid models, so if the clearance is wrong, you can relerance it by just pulling those holes in or out.

[00:05:05]The knees have one stainless steel rod pushed all the way through, which should be tight, but it should be loose again on those sticks for the actual leg uprightes. So, those are free to move. I reinforce the plastic pivot points there with some 4mm stainless steel as well.

[00:05:20]And that's because once the servo is inserted, there's hardly any plastic under the base of it to put the whole axle in. So, it won't be strong enough.

[00:05:28]So, now we should see that we have two axles and they both are opposite each other to give those pivot points. The hit points are really similar. So, we have an axle opposite the servo output.

[00:05:38]And then we have another axle to make the other pivot point. And that's the same on both sides, which are of course opposites. And again, we've got the same clearance so that the steel rods are shoved in nice and tight. And those pivot points are free to move. And that makes up the main parts for the legs.

[00:05:55]So, I've mounted my servos into the blocks, and I've mounted the horns on there. And I line those up with the protractor to get them at roughly 45° in the middle position. And to get the middle position, I just use one of these servo testers to turn the servo. All of that can actually be done later when the electronics are here. But I want to get it assembled right first time cuz I actually haven't built my electronics yet. So I've got all these other pieces.

[00:06:19]So let's put the struts together that make up the legs and get the body on.

[00:06:23]And we'll look at the overall mechanics.

[00:06:25]The bottom and top of the leg are essentially two parallelograms. And that means we only need two servos per leg instead of separate ankle, knee, and hip joints. But some of the uprightes are different because they have those plastic pivot points basically for strength. So some of them have bigger loops in. And it's important that you print the right quantity of each of the different uprightes. Again, on the lower leg here, we have one with a steel at each end. And then we have a special one with a cutout and that's mounted onto the servo. And at the other end, there is a little pivot point. That one itself has a plastic pivot point on. So, it's important to check you're printing the right parts. These attach to the servo horns with two M3 bolts. A long one that goes right into the servo and holds the horn on, and a short one that just goes into that metal servo horn, which are already tapped to M3. I've also got some plates that fit on the parallel joints, and that stops everything falling to pieces. So, there's the main action of the foot with its parallel servo motion, and that seems to be working okay, and we get quite a range of motion. The upper leg is really similar with some of these uprightes going between the 4mm steel and some having loops. On the other side, we've got one with a loop and then we've got one with a special piece and that again goes onto that top servo to make up the rest of the parallelogram. And again, those servos are tied in with two M3 bolts at the top. So, there's no possibility of the levers slipping on the servo output. And we get quite a good range of motion here, although I don't think we're actually going to need it to walk along.

[00:07:52]And of course, there are two legs which are built as opposites. And that's really important so you don't end up with two right legs or two left legs. On top of each leg goes one of these round towers, which are of course opposite parts as well. And those are just screwed on to the red parts with some selftapping screws. To allow those to rotate, we have a body section which has holes in. And that is two plates which are screwed onto a tower in the middle with holes to let wires through. So of course that slots on. And then if we get everything aligned, it should be fairly well toleranced. We can rotate the legs.

[00:08:24]So that means it can turn on the spot and hopefully walk in a curve. In order to save the number of servos used, I've tied these two towers together with these big gears. The gears are actually different. You'll notice one has two little holes on it on the right hand side and one has one little hole. And that's important for alignment because the gears aren't in the same place.

[00:08:44]We've got one more servo and that's got one little gear on here. That's a 2:1 reduction. And that means we can operate that servo and it'll move the legs just the right amount for the right sort of velocity that we need to turn on the spot. I'm going to make some feet here.

[00:08:58]And I'm printing these in TPU. So these are two perimeters and a 15% infill. And I'm using Polymaker Polylex TPU90 high flow. So 1.75 mm filament. And that again is printed on the pusches with a 0.4 mm nozzle. So that's an extremely good print for TPU. And those just slot onto my feet now onto the little dovetail things I left there. And then we've got some screw holes to screw them on. Those feet are quite squashy. And it turns out that that's actually quite important.

[00:09:29]And the reason for having absorbent feet is, of course, that we don't have hip and ankle motors to lean sideways. So, this thing is going to have to regulate itself, tipping like this by bending its legs at the right time and balancing so that it can pick its feet up off the ground. So, it's quite good to have these rubber feet cuz then it doesn't bang on the table too much and that'll probably help quite a bit with the dynamics. The electronics again is going to be ESP32 just like last time. And this time I've made a slightly more stylish remote. So, let's get some electronics in and see how it's going to balance. ESP now is a very simple way to get the data between two ESP32s wirelessly. It's technically Wi-Fi, but you don't need to attach to any Wi-Fi base units. You can just send data straight to the hardware address of the other ESP32 and they connect straight away at powerup. I found a really good tutorial on this at random nerdutorials.com which has example code which works well. First of all, we're going to use some code to get the MAC address of the receiving ESP32 and then that address goes into the transmitter code so it sends the data directly to the correct receiver. As usual, I'm building this on perma protoboard which is a PCB laid out exactly like breadboard. So, it's really easy and it comes in different sizes. I put my ESP32 on a piece of that board with an analog joystick and two digital buttons so we can scroll up and down between functions like a menu system. On the back, there's four AAA batteries to give us 6vts. And that goes to the Vin of the ESP32 to power it. And I left a little window so we can see the light. On the robot end, there's another ESP32 which has RON for receiver and that also has an inertial measurement unit attached. This is a Spark Fun BNO086 inertial measurement unit and it's wide to the ESP32 with I squared C. So now I have my remote data over ESP now. So I've got two buttons to toggle functions and I've also got the joystick data there which ranges pretty well with good ranges of values and my thumb stick works well. We've also got the inertial measurement unit data. It actually produces three axes of motion and it gives you the actual angle in degrees as well as your which is the rotation axis. We only need one which is going to be the roll of the robot but it's actually the pitch from the IMU because the IMU is mounted sideways like that and that's the angle we need as the robot tips side to side. So as we tip the robot we can now see the data side to side. It's the role of the robot, but the pitch axis from the IMU, unless you mount it wrong.

[00:12:01]Have you ever thought about adding more intelligence like machine vision to your projects, but you don't know how to link everything together? Well, a company called Numerous reached out about doing a sponsored video. They make a software platform called Nepi. Nepi is the software platform for edge AI and automation. Connect sensors, deploy AI models, and take automated actions. You can prototype in days without building everything from scratch. It's built on ROS and all the source code is available and it runs on a Docker container on any Linux machine in minutes. It's free to try and no accounts required. The way it works is that Nepi handles 90% of what most automation projects require out of the box. Hardware drivers, AI model management, automation tools, a browserbased UI server that runs on the device. So instead of spending months coding all the plumbing for an automation project, you can jump to the last 10% that's actually unique to what you're building. The setup's really easy with full instructions of exactly what to type to install Nepi. Check out the quick start camera to AI tutorial. I used a basic USB webcam and it was possible to quickly select an AI model to recognize people or objects. And once you've got the detection data, you can use that in scripts to interface to other hardware. Nepi also supports Argupilot integration for autonomous vehicles. It runs on hardware you probably already have a Jetson, a Pi 5, or even a Linux laptop. And all the instructions and source code are on GitHub to start creating customized project solutions. If you want to try it, the easiest way is the container, one docker pull, and you're up and running. Go to nepi.com/container/getstarted and I'll put that link in the description as well. Leave a comment in the video comments if you want to see me use Nepi for an automation project.

[00:13:40]Whatever ideas you've got, put them down there and perhaps we'll do a whole video about using it. I need to attach my five servos to the ESP32. I've just used some wires and pin strip to make connectors to attach to those digital pins. And I'm using a separate power rail on this piece of perma proto board to distribute power for those. There's a battery in the back in a little clip and that is a 2S lipo around 8 volts. I've got two switches on the side. One of those is for the ESP32 and one is to deliver power to the servos. So if I switch the other switch on, they should go to their default positions. Now I have used an additional linear 5V regulator here to get the 8 volts from the battery to power the ESP32V in because sometimes the regulators on board don't like it and they get hot. So we now have a robot here in its default positions with its 45° legs and that's looking pretty good.

[00:14:33]I did make a jig that goes in the bottom here so you can get the legs defaulted to the right angle and that's really important otherwise all the inverse kinematics will break which I'll come on to in a moment. And it's important those legs are parallel. You could use a protractor, of course, to try and get those joints at 45°. And make sure it's all set up right. The legs, of course, should be parallel at the front as well, so they're not facing in or out. And the best thing to do is align them mechanically. And then set the offsets in the specific section of the code to fine-tune it. So now it should be standing straight and well balanced.

[00:15:05]There is some slop in the joints, but it should be pretty symmetrical. So the plan is we're going to pump each leg and hopefully we're going to get it to hobble from leg to leg basically.

[00:15:14]Obviously it doesn't have any hip or ankle joints sideways and we need to regulate that with the inertial measurement unit so it doesn't overbalance and then take steps so that we can walk along. But what we need to do first is some inverse kinematics and that's so we can plan the foot path and we can also interpolate between positions so that we can move the legs up and down in a straight line. As we move the foot around, of course, it means that the two joints at the top and bottom of the leg move to varying amounts. So to move that foot forward and backwards in a straight line is going to involve some calculations as to what the angle should be that we can drive the servos with. The leg is basically a triangle and we know two of its sides. We want to specify the length and then work out the angles, which is easy to do with Pythagoras theorem and trigonometry. I just went on mathsfund.com to remember how to solve triangles. Once we can specify the leg length, we can imagine that's one side of another right angle triangle. We can specify the height of the robot and the foot position back and forth and calculate the hypotenuse of the triangle which we passed to the previous calculation. I've done this a number of times including in the atat I can ride on. And the math looks like a bunch of trigonometry functions in the code. So now as I move the joystick up and down, the robot goes up and down in a perfectly straight line. And if I move that joystick sideways, then it should go sideways or back and forward in a perfectly straight line as well, calculating the joint angles as it does so. But now we need to be able to plan the foot path and make it move how we want without me just wiggling the joystick.

[00:16:49]So in a really similar way to the atat, we need to be able to move each foot on a path to walk. If we move all the motors at the same speed and try to move the foot from one point to another, then one motor will finish before the other in each leg. So, we won't get a straight line. I'm using the Arduino ramp library to interpolate between the start and end positions for each foot move. That creates the same effect as me moving through all the points by scrolling around with the joystick. We can then feed all the points on the path into the inverse kinematics.

[00:17:20]So, what we want is to pump each leg like this and have it rock onto each foot. And we need to make it stable and it needs to walk about this pace. So, there's time to take actual steps.

[00:17:32]So, of course, if I let go of this though, oh, it gets stuck or it falls over. So, only really works when I hold on to it.

[00:17:42]Oh, nearly.

[00:17:46]If I speed it up so it's twice as quick, then it does actually stay stable, but um it's not using any active balance.

[00:17:53]And you can see it's kind of like getting stuck on one side a lot and it's not very symmetrical. But it's quite hopeful that we can make this work. So what we need to do now is bring in the inertial measurement unit to try and keep this upright and try and regulate it. So it looks like it's doing what it should be doing and it's got time to take steps.

[00:18:13]Let's look at that inertial measurement unit data again. is really very responsive and there's not much noise really. That's a really smooth line. So, let's start this up again. Even though it's banging into the ground, we can see quite clearly that if the robot tips over to one side too much, all the data becomes too positive. And if it tips over the other way, then all the data becomes too negative. And that means it gives us a very good idea of what the response is and where the robot is. So, we can correct for it.

[00:18:40]My table's actually really wobbly and that's going to have an effect of absorbing some load and affecting the dynamics. So, I'm doing this on a piece of wood on the floor. If I try to balance a stick with some mass on top on my hand, it's pretty easy. That's cuz the mass has lots of inertia. So, basically, it doesn't move as quick, so I don't have to respond as quick. On the other hand, if I try to balance a really small light stick, it's really, really hard cuz I have to respond much quicker to balance it. My robot's quite small this time, so I've added four M20 nuts on top to give it a higher point of inertia. I've now incorporated the inertial measurement unit, so we have some rudimentary dynamic stability. So, you can see it's treading fairly consistently, and if it gets stuck on one side, it corrects itself. The timer on the right is the time between the steps, and all it's doing is if it falls over too much, it's increasing the timer, so it's longer before it takes the next step. And that's it really for now. Obviously, the cable is dragging and having an effect, which is why it's walking backwards and into a corner.

[00:19:40]The previous robot had a much wider stance. Its legs were further apart, and those rubber rails that it's walking on are much further apart as well. So, I've made my life easy, and I've just moved the feet further apart on this robot.

[00:19:53]And those TPU bumpers essentially have just moved apart by making new PLA feet.

[00:19:58]I also added an additional nut on each side to add a higher point of inertia.

[00:20:03]As well as the mechanical changes, I've only made one other change to the code.

[00:20:07]So, as well as increasing the time between steps, which is the left-hand timer, it decreases the time to take each step, which is the right hand timer. That timer, though, is in fact used four times to put the foot down, wait for some time, then put it up again, and wait for some time. So, we've got some dwell time to take steps. I've removed the USB cable now because I don't need to monitor the timers. And we can see that works fairly consistently and it doesn't walk backwards and into a corner anymore. It's surprising how much extra drag that sort of thing causes and how it affects the dynamics. And this is able to regulate itself now pretty reliably. You can't really see with the human eye that it's speeding up and slowing down. It also works on carpet quite well. So, I'm quite happy with that. And that will just carry on walking like that for as long as I leave it until the battery goes flat. We're probably pushing the maximum speed of the servos, although it actually moving the legs up and down around 15 mm and that's enough to push it side to side.

[00:21:04]Here's another test on a workbench which is a bit bouncy and that seems to work quite well. It is sort of a solid frame, but it's only a thin plywood top and so that seems to be working okay as well.

[00:21:16]So, pretty happy of how well this is able to regulate itself and it will just carry on like that until I stop it.

[00:21:24]So now I'm using the front and back axis of the joystick to have it actually take steps. So when one foot is up and one way is down, they move in the opposite direction depending on how far you push that joystick forward and the opposite if you push it backwards. So hopefully that makes a walking motion and it's able to walk backwards and forwards.

[00:21:41]We've still got that other servo though for rotating which does the same thing when one foot is up and one foot is down. It moves the feet apart by moving that servo in one direction and the opposite when you push the stick the other way. So that should hopefully enable it to turn on the spot. And if we're very lucky, it should be able to walk in a curve by mixing both joystick actions together.

[00:22:03]So it's time to give it a test. I'm just walking on carpet here and is a bit slippery with those smooth TPU feet, but it does seem to walk along pretty well.

[00:22:11]At least well enough for something with five servos. And it can turn as well as it walks. Now, it seems to walk what I intended to be backwards, slightly better than walking forwards. And I believe Boston Dynamics did some research on which way to bend the legs, which is why the Spot Mini legs appear to bend backwards. But, um, yeah, pretty happy with that. This way, it walks quite a bit better. You can see those smooth TPU feet are slipping slightly on the carpet because they are smooth and the carpet has some absorption. So, I'm pretty happy with this altogether. And you can see it's picking its feet up pretty well, which was one of the requirements. and it is regulating itself. Okay, it's not getting stuck on one side and each foot is definitely being picked up properly despite the foot slippage which would really impact a human if you're walking on ice of course.

[00:23:11]So, on a very smooth hard surface like these very smooth tiles, obviously the TPU doesn't grip at all. I'm surprised it works at all actually, and it seems to be regulating itself not too badly and recovering. But, of course, when I try and do anything like turning, it's like it's on ice skate slipping on ice.

[00:23:27]So, now it's time for some experimentation. I've got some of this anti-slip dashboard stuff for cars that stops your phone slipping on the dashboard, basically. And I've put that on the feet with some 3D printed rails to hold it on. So, let's see what happens now.

[00:23:41]Well, we can see that extra absorption has actually impacted the dynamics quite a lot. So, it's kind of okay if I help it, but now it's a bit spongy. So, um it can kind of work, but it's not great, unfortunately. And you can see it gets stuck on one side quite a bit, and that's really affected the dynamics much more than I thought it would.

[00:24:09]So, I thought I'd make my life easier and I just added two more nuts, one to each side. And now that seems to have just fixed it completely, and it works fine. So, it's really surprising the mass distribution has such an impact on this. Obviously, we've got no sort of learning here for it carrying a load and being able to adjust itself. It's just these timers with a little bit of variation depending on how far it's falling over, but now it works because it falls over less quickly. So, um, yeah, it works fine. It's able to walk along and it's able to turn. So, if you are going to build one of these, then it's going to be highly experimental.

[00:24:43]You might need more or less mass. You could also try a big stick on the top with the mass even higher. That would slow it down even more, but then all the timers would have to change, so it would work at all, I expect. And you could try different foot surfaces, maybe just PLA feet that don't have those TPU bumpers on and some grippy surface on those.

[00:25:00]Perhaps some stick on rubber feet that are much denser than that foam stuff that I used. But on the whole, pretty happy this works. Five servos, an ESP32 and an IMU, and some 3D prints that you can make at home.