Building an animatronic robot is one thing, but animating it in a lifelike fashion is a completely different challenge. Hobby servos are cheap and popular for animatronics, but just letting it move at max speed isn’t particularly lifelike. In the video after the break, [James Bruton] demonstrates how to achieve natural motion with a simple animatronic head and a few extra lines of code.

Very little natural body movement happens at a constant speed, it’s always accelerating or decelerating. When we move our heads to look at something around us, our neck muscles accelerate our head sharply in the chosen direction and then slows down gradually as it reaches its endpoint. To do this in Arduino/C code, a new intermediate position for the servo is specified for each main loop until it reaches the final position. The intermediate value is the sum of 95% of the current position, and 5% of the target position. This gives the effect of the natural motion described above. The ratios can be changed to suit the desired speed.

The delay function is usually one of the first timing mechanisms that new Arduino programmers learn about, but it’s not suited for this application, especially when you’re controlling multiple servos simultaneously. Instead, the millis function is used to keep track of the system clock in the main loop, which fires the position update commands at the specified intervals. Adafruit wrote an excellent tutorial on this method of multitasking, which [James] based his code on. Of course, this should be old news to anyone who has been doing embedded programming for a while, but it’s an excellent introduction for newcomers.

Like most of [James]’s projects, all the code and CAD files are open source and available on GitHub. His projects make regular appearances here on Hackaday, like his mono-wheel balancing robot and mechanically multiplexed flip-dot display.

Walking robots were once the purview of major corporations spending huge dollars on research programs. Now, they’re something you can experiment with at home. [Technovation] has been doing just that with his micro quadruped build.

The build runs twelve servos – three per leg – to enable for a great range of movement for each limb. The servos are all controlled by an Arduino Uno fitted with an Arduino Sensor Shield. Everything is fitted together with a 3D printed chassis and limb segments that bolt directly on to the servo output shafts. This is a common way of building quick, easy, lightweight assemblies with servos, and it works great here. Inverse kinematics is used to calculate the required motions of each joint, and the robot can take steps from 1 to 4cm long in a variety of gaits.

We’d love to see a few sensors and a battery pack added on to allow the ‘bot to explore further in an untethered fashion. [Technovation] has left some provision to mount extra hardware, so we look forward to seeing what comes next.

We’ve seen bigger quadrupeds do great things, too. Video after the break.

Like us, [Alberto] doesn’t compromise when it comes to a good cup of coffee. We figure that if he went to an office in the Before Times, he was the type of coworker to bring in their own coffee equipment so as not to suffer the office brew. Or perhaps he volunteered to order the office supplies and therefore got to decide for everyone else. Yep, that’s definitely one way to do it.

But like many of us, he is now operating out of a home office. Even so, he’s got better things to do than stand around pouring the perfect cup of coffee every morning. See, that’s where we differ, [Alberto]. But we do love Cafeino, your automated pour-over machine. It’s so sleek and lovely, and we’re sure it does a much better job than we do by hand — although we enjoy doing the pouring ourselves.

Cafeino is designed to mimic the movements of a trained barista’s hand, because evidently you’re supposed to pour the water in slow, deliberate swirls to evenly cover the grounds. (Our kettle has a chunky spout, so we just sort of wing it.) Cafeino does this by pumping water from an electric kettle and pouring a thin stream of it in circles with the help of two servos.

The three buttons each represent a different recipe setting, which specifies the amount of water, the hand pouring pattern, and the resting times between blooming the grounds and actually pouring the bulk of the water. These recipes are set using the accompanying web app via an ESP32, although the main brain barista is an Arduino Nano. Grab a cup and check out the demo after the break.

Got an old but modern coffee robot lying around? You could turn it into a planter with automated watering.

The HackadayPrize2021 is Sponsored by:

While early scientists and inventors famously underestimated the value of radar, through the lens of history we can see how useful it became. Even though radar uses electromagnetic waves to detect objects, the same principle has been used with other propagating waves, most often sound waves. While a well-known use of this is sonar, ultrasonic sensors can also be put to use to make a radar-like system.

This ultrasonic radar project is from [mircemk] who uses a small ultrasonic distance sensor attached to a rotating platform. A motor rotates it around a 180-degree field-of-view and an Arduino takes and records measurements during its trip. It interfaces with an application running on a computer which shows the data in real-time and maps out the location of all of the objects around the sensor. With some upgrades to the code, [mircemk] is also able to extrapolate objects hidden behind other objects as well.

While the ultrasonic sensor used in this project has a range of about a meter, there’s no reason that this principle couldn’t be used for other range-finding devices to extend its working distance. The project is similar to others we’ve seen occasionally before, but the upgrade to the software to allow it to “see” around solid objects is an equally solid upgrade.

Ever wanted your own gesture-controlled robot arm? [EbenKouao]’s DIY Arduino Robot Arm project covers all the bases involved, but even if a robot arm isn’t your jam, his project has plenty to learn from. Every part is carefully explained, complete with source code and a list of required hardware. This approach to documenting a project is great because it not only makes it easy to replicate the results, but it makes it simple to remix, modify, and reuse separate pieces as a reference for other work.

[EbenKouao] uses a 3D-printable robotic gripper, base, and arm design as the foundation of his build. Hobby servos and a single NEMA 17 stepper take care of the moving, and the wiring and motor driving is all carefully explained. Gesture control is done by wearing an articulated glove upon which is mounted flex sensors and MPU6050 accelerometers. These sensors detect the wearer’s movements and turn them into motion commands, which in turn get sent wirelessly from the glove to the robotic arm with HC-05 Bluetooth modules. We really dig [EbenKouao]’s idea of mounting the glove sensors to this slick 3D-printed articulated gauntlet frame, but using a regular glove would work, too. The latest version of the Arduino code can be found on the project’s GitHub repository.

Most of the parts can be 3D printed, how every part works together is carefully explained, and all of the hardware is easily sourced online, making this a very accessible project. Check out the full tutorial video and demonstration, embedded below.

3D printing has been a boon for many projects, especially those involving robotic arms. All kinds of robotic arm projects benefit from the advantages of 3D printing, from designs that focus on utility and function, to clever mechanical designs that reduce part count in unexpected ways.

What could be more terrifying than ghosts, goblins, or clowns? How about a shapeless pile of fright on your bedroom floor that only moves when you’re not looking at it? That’s the idea behind [Sciencish]’s nightmare robot, which is lurking after the break. The Minecraft spider outfit is just a Halloween costume.

In this case, “looking at it” equates to you shining a flashlight on it, trying to figure out what’s under the pile of clothes. But here’s the thing — it never moves when light is shining on it. It quickly figures out the direction of the light source and lies in wait. After you give up and turn out the flashlight, it spins around to where the light was and starts moving in that direction.

The brains of this operation is an Arduino Uno, four light-dependent resistors, and a little bit of trigonometry to find the direction of the light source. The robot itself uses two steppers and printed herringbone gears for locomotion. Its chassis has holes in it that accept filament or wire to make a cage that serves two purposes — it makes the robot into more of an amorphous blob under the clothes, and it helps keep clothes from getting twisted up in the wheels. Check out the demo and build video after the break, because this thing is freaky fast and completely creepy.

While we usually see a candy-dispensing machine or two every Halloween, this year has been more about remote delivery systems. Don’t just leave sandwich bags full of fun size candy bars all over your porch, build a candy cannon or a spooky slide instead.

Via r/duino

One of the side effects of the rise of 3D printers has been the increased availability and low cost of 3D printer components, which are use fill for range of applications. [How To Mechatronics] capitalized on this and built a SCARA robot arm using 3D-printed parts and common 3D-printer components.

The basic SCARA mechanism is a two-link arm, similar to a human arm. The end of the second joint can move through the XY-plane by rotating at the base and elbow of the mechanism. [How To Mechatronics] added Z-motion by moving the base of the first arm on four vertical linear rods with a lead screw. A combination of thrust bearings and ball bearings allow for smooth rotation of each of the joints, which are belt-driven with NEMA17 stepper motors. Each joint has a microswitch at a certain position in its rotation to give it a home position. The jaws of the gripper slide on two parallel linear rods, and are actuated with a servo. For controlling the motors, an Arduino Uno and CNC stepper shield was used.

The arm is operated from a computer with a GUI written in Processing, which sends instructions to the Arduino over serial. The GUI allows for both direct forward kinematic control of the joints, and inverse kinematic control,  which will automatically move the gripper to a specified coordinate. The GUI can also save positions, and then string them together to do complete tasks autonomously.

The base joint is a bit wobbly due to the weight of the rest of the arm, but this could be fixed by using a frame to support it at the top as well. We really like the fact that commonly available components were used, and the link in the first paragraph has detailed instructions and source files for building your own. If the remaining backlash can be solved, it could be a decent light duty CNC platform, especially with the small footprint and large travel area. This is very similar to a wooden SCARA robots we’ve seen before, except that one put the Z-axis at the gripper. We’ve also seen a few 3D printers and pen plotters that used this layout.

The internet has given us plenty of cool robotics projects, but we don’t think we’ve seen one zipline before. At least not until now.

This cool little ziplining robot is courtesy of the folks over at [Tart Robotics]. As they described it, the robot moves using a 4-bar linkage mechanism with the motor’s torque “transferred to the arm mechanisms through a pair of bevel gears and a worm drive.” Even cooler, the robot is activated by clapping. The faster you clap, the faster the robot moves. That’s sure to wow your friends at your next virtual hacker meetup.

They had to do a bit of custom 3D printing work to get a few of the Lego components to connect with their non-Lego off-the-shelf bits, so that took a bit of time. Specifically, they had some cheap, non-branded DC motors that they used that did not naturally mate with the Lego Technic components used to create the rest of the robot’s body. Nothing a few custom 3D printing jobs couldn’t solve.

It always amazes us what cool contraptions you can put together with a few Lego blocks. What’s your favorite Lego project?

A set of helping hands is a nice tool to have around the shop, especially if soldering or gluing small components is a common task. What we all really want, though, is a robotic arm. Sure, it could help us set up glue or solder but it can do virtually any other task it is assigned as well. A general-purpose tool like this might be out of reach of most of us, unless we have a 3D printer to make this open-source robotic arm at home.

The KAUDA Robotic Arm from [Giovanni Lerda] is a five-axis arm with a gripping tool and has a completely open-source set of schematics so it can be printed on any 3D printer. The robot arm uses three stepper motors and two servo motors, and is based on the Arduino MEGA 2560 for control. The electrical schematics are also open-source, so getting this one up and running is just an issue of printing, wiring, and implementing some software. To that end there are software examples available, and they can easily be modified to fit one’s robotic needs.

A project like this could be helpful for any number of other projects, or also just as a lesson in robotics for yourself or even in a classroom, since many schools now have their own 3D printers. With everything being open-source, this is a much simpler endeavor now than other projects we’ve seen that attempted to get robotic arms running again.

Who doesn’t love robotic spiders? Today’s biomimetic robot comes in the form of Miles, the quadruped spider robot from [_Robox].

Miles uses twelve servos to control its motion, three on each of its legs, and also includes a standard HC-SR04 ultrasonic distance sensor for some obstacle avoidance capabilities. Twelve servos can use quite a bit of power, so [_Robox_] had to power Miles with six LM7805 ICs to get sufficient current. [_Robox_] laser cut acrylic sheets for Miles’s body but mentions that 3D printing would work as well.

Miles uses inverse kinematics to get around, which we’ve seen in a previous project and is a pretty popular technique for controlling robotic motion. The Instructable is a little light on the details, but the source code is something to take a look at. In addition to simply moving around [_Robox_] developed code to make Miles dance, wave, and take a bow. That’s sure to be a hit at your next virtual show-and-tell.

By now you’re saying “wait, spiders have eight legs”, and of course you’re right. But that’s an awful lot of servos. Anyway, if you’d rather 3D print your four-legged spider, we have a suggestion.