Robot Pet Is A Chip Off The Old Logic Block

August 15, 2021 by Ryan Flowers 10 Comments

When [Ezra Thomas] needed inspiration for his senior design project, he only needed to look as far as his own robot. Built during his high school years from the classic 1979 Frank DaCosta book “How to Build Your Own Working Robot Pet”, [Ezra] had learned the hard way the many limitations and complexities of the wire wrapped 74xx series logic chips surrounding its 8085 processor.

[Ezra] embarked on a quest to recreate the monstrosity in miniature, calling it Pet on a Chip. Using a modern FPGA chip allows the electronics to shrink by an order of magnitude and provides flexibility for future expansion. Implementing an 8 bit CPU on the amply sized FPGA left plenty of room for a VGA GPU, motor controller, serial UART, and more. Programming the CPU is handled by a custom assembler written in Python.

The results? Twelve times less weight, thirteen times less power draw, better performance, and a lot of room for growth. [Ezra] hints at an I2C bus expansion as well as a higher level programming language to make software development less of a hurdle.

The Pet On A Chip is a wonderfully engineered project and we hope that we’ll be seeing more such from [Ezra] as time goes by. Watch his Pet On A Chip in action in the video below the break.

If [Ezra]’s FPGA escapades have you wondering how to get started, you can check out this introduction to FPGA from the 2019 Hackaday Superconference. And if you have your own FPGA creation to share, please let us know via the Tip Line!

Continue reading “Robot Pet Is A Chip Off The Old Logic Block” →

Unique Strandbeest Stands Tall With Line Of Legs

June 8, 2020 by Tom Nardi 1 Comment

Multiple rows of intricately articulated legs are the defining characteristic of the Strandbeest, but [James Bruton] wondered if he could reduce that down to a single row using the same principles at work in a self-balancing two wheeled robot. While it’s perhaps a bit early to call his experiments a complete success, the first tentative steps taken by his (relatively) svelte Strandbeest certainly look promising.

Initially the robot only had two pairs of legs, but in testing [James] found this arrangement to be a bit unstable. By bringing the total count to four legs per side and improving the counterweight arrangement, the bot has been able to walk the length of the workshop. Unfortunately, an issue with the leg design seems to be preventing the Strandbeest from taking any backward steps.

Normally this wouldn’t be that big of a problem, but in this case it’s keeping the Strandbeest from being able to self-balance while standing still. In other words, the robot needs to keep moving forward or it will fall over. Still, [James] thinks the idea has promise and wants to continue experimenting with the bot in a larger area.

Specifically, he wants to see if the dual-motor robot can turn by varying the speed the two sets of legs are running at. If it can walk in a tight enough circle, it could keep right on marching until the power runs down. Sounds more than a little nightmarish to us, but we’d still like to see it.

Reader’s may recall [James] from this other another robotic projects, such as the phenomenal OpenDog. We don’t know where his obsession of legged robots comes from, but we certainly aren’t complaining.

Continue reading “Unique Strandbeest Stands Tall With Line Of Legs” →

Sonic The Self-Balancing Robot: Face-Plants And The Challenges Of Sensor Integration

February 26, 2020 by Danie Conradie 2 Comments

Watching a child learn to run is a joyous, but sometimes painful experience. It seems the same is true for [James Bruton]’s impressive Sonic the Self-Balancing robot, even with bendable knees and force sensitive legs.

We covered the mechanical side of the project recently, and now [James] has added the electronics to turn it into a truly impressive working robot (videos after the break). Getting it to this point was not without challenges, but fortunately he is sharing the experience with us, wipe-outs and all. The knees of this robot are actuated using a pair of motors with ball screws, which are not back drivable. This means that external sensors are needed to allow the motors to actively respond to inputs, which in this case are load cells in the legs and an MPU6050 IMU for balancing. The main control board is a Teensy 3.6, with an NRF24 module providing remote control.

[James] wanted the robot to be able to lean into turns and handle uneven surfaces (small ramps) without tipping or falling over. The leaning part was fairly simple (for him), but the sensor integration for uneven surfaces turned out to be a real challenge, and required multiple iterations to get working. The first approach was to move the robot in the direction of the tipping motion to absorb it, and then return to level. However, this could cause it to tip over slightly larger ramps. When trying to keep the robot level while going over a ramp with one leg, it would go into wild side-to-side oscillations as it drops back to level ground. This was corrected by using the load cells to dampen the motion.

Continue reading “Sonic The Self-Balancing Robot: Face-Plants And The Challenges Of Sensor Integration” →

Sonic The Hedgehog Self-Balancing Robot Can Bend At The Knees

January 31, 2020 by Danie Conradie 4 Comments

Building your own self-balancing robot is a rite of passage for anyone getting into the field of robotics. Master of robots, [James Bruton] has been there, done that, and collected a few T-shirts. Now he’s building a large Sonic the Hedgehog self balancing robot that can bend at the knees and hip, allowing it to lean while turning and handle uneven terrain. Check out the first video embedded after the break.

Standing about 1 m tall, the robot is inspired by Boston Dynamic’s box handling bot, Handle. It’s “skeleton” consists of 20×20 aluminium extrusions, bolted together using a bunch of 3D printed fittings in the signature blue and red of Sonic. The wheels and tyres are also 3D printed, and driven by brushless motor via a toothed belt. The knee/hip mechanism is actuated using a ball screw, also driven by a brushless motor.

[James] intends to implement an active shock absorption system into the leg mechanism, using the same technique he tried on his OpenDog robot. It works by bolting a load cell onto one of the leg extrusion to sense when it flexes under load, and then actuating the knee mechanism to absorb the force. His first version of the system on OpenDog used PWM signals to send the load cell data to the main controller, but the motors on the legs induced enough noise in the signal wires to make it unusable. He has since started experimenting with the CAN bus protocol, which was specifically designed to work reliably in noisy systems like modern automobiles. If he gets it working on the two legs of this Sonic robot, he plans to also implement it on the quadruped OpenDog.

Continue reading “Sonic The Hedgehog Self-Balancing Robot Can Bend At The Knees” →

Wiping Robots And Floors: STM32duino Cleans Up

June 21, 2018 by Tucker Ervin 12 Comments

Ever find yourself with nineteen nameless robot vacuums lying around? No? Well, [Aaron Christophel] likes to live a different life, filled with zebra print robots (translated). After tearing a couple down, only ten vacuums remain — casualties are to be expected. Through their sacrifice, he found a STM32F101VBT6 processor acting as the brains for the survivors. Coincidentally, there’s a project called STM32duino designed to get those processors working with the Arduino IDE we either love or hate. [Aaron Christophel] quickly added a variant board through the project and buckled down.

Of course, he simply had to get BLINK up and running, using the back-light of the LCD screen on top of the robots. From there, the STM32 processors gave him a whole 80 GPIO pins to play with. With a considerable amount of tinkering, he had every sensor, motor, and light under his control. Considering how each of them came with a remote control, several infra-red sensors, and wheels, [Aaron Christophel] now has a small robotic fleet at his beck and call. His workshop must be immaculate by now. Maybe he’ll add a way for the vacuums to communicate with each other next. One robot gets the job done, but a whole team gets the job done in style, especially with a zebra print cleaner at the forefront.

If you want to see more of his work, he has quite a few videos on his website demonstrating the before and after of the project — just make sure to bring a translator. He even has a handy pinout for those looking to replicate his work. If you want to dive right in to STM32 programming, we have a nice article on how to get it up and debugged. Otherwise, enjoy [Aaron Christophel]’s demonstration of the eight infra-red range sensors and the custom firmware running them.

Building A Self-Balancing Robot Made Easy

June 3, 2017 by Steven Dufresne 14 Comments

Not only has [Joop Brokking] built an easy to make balancing robot but he’s produced an excellent set of plans and software for anyone else who wants to make one too. Self-balancers are a milestone in your robot building life. They stand on two-wheels, using a PID control loop to actuate the two motors using data from some type of Inertial Measurement Unit (IMU). It sounds simple, but when starting from scratch there’s a lot of choices to be made and a lot of traps to fall into. [Joop’s] video explains the basic principles and covers the reasons he’s done things the way he has — all the advice you’d be looking for when building one of your own.

He chose steppers over cheaper DC motors because this delivers precision and avoids issues when the battery voltage drops. His software includes a program for getting a calibration value for the IMU. He also shows how to set the drive current for the stepper controllers. And he does all this clearly, and at a pace that’s neither too fast, nor too slow. His video is definitely worth checking out below.

Continue reading “Building A Self-Balancing Robot Made Easy” →

Rolly Bot Puts A New Spin On Independent Wheel Control

August 7, 2014 by Kristina Panos 38 Comments

rolly bot

All of [Darcy]’s friends were making wheeled robots, so naturally, he had to make one too. His friends complicated theirs with h-bridges and casters for independent wheel maneuvering, but [Darcy] wanted something simpler. A couple of 9g servos later, the Rolly Bot was born.

Rolly Bot is self-balancing because of its low center of gravity. Should it hit a wall, the body will flip over, driving it back in the other direction. The BOM comes to a whopping $10, and that includes continuous rotation servos. It does not include the remote control capability he added later, or the cost of the CNC you would need to completely replicate this build. He even made a stand so he could test the wheels during programming.

[Darcy]’s code is on his site along with some pictures of another version someone else built. Watch Rolly Bot roll around after the jump.

How would you make this build even simpler? Tell us in the comments.

Continue reading “Rolly Bot Puts A New Spin On Independent Wheel Control” →