Monthly Archives: March 2017

Particle Flow makes granules tumble in interesting patterns

via Arduino Blog

This Arduino-based project creates interesting tumbling patterns using a system that tilts a plane in a controlled manner while deforming its surface.

NEOANALOG, a “studio for hybrid things and spaces,” was commissioned to build the Particle Flow installation, which explores how granules tumble under the control of gravity. This mechanism takes the form of a large hexagon held in three corners by linkages pushed up and down by NEMA 24 stepper motors. As these rods are lifted, the granules inside the “arena” are steered over to the opposite side producing a zen-like experience.

Inside the main hexagon are 19 smaller hexagons, each controlled by servos to lift an individual section of the rolling surface up and down. Control of the entire system is accomplished via a PC running Processing, which sends commands via Ethernet to an Arduino Mega and the steppers to an Arduino Uno with three motor drivers. 

A moving slanted plane and a grid of motorized stamps control the elements to form infinite variations of behaviors and patterns. The result is a zen-like experience that is both: fascinating and contemplative. Software controlled motion follows a complex choreography and enables precise steering of physical particles in a variety of ways: from subtle to obvious, from slow to high paced, from random-like to symmetric.

Intrigued? Be sure to check out Creative Applications Network’s write-up on this piece as well as NEOANALOG’s page for more details.

Friday Product Post: All THAT

via SparkFun Electronics Blog Posts

Hey there, SparkFun crowd. I’m going to let you finish your regularly scheduled product post, but first I wanted to let you know that the Arduino Day Sale starts now!!! Click this giant image below for more details and enjoy your new products. Mic drop…

alt text

…Hello there, everyone! Fresh out tha box. Stop, look and watch. Ready yet, get set. It’s All THAT! This week we are pleased to bring you two new audio breakout boards that utilize the InGenius analog line receiver and the OutSmarts analog line driver chips from THAT Corporation. On top of that, we also have a brand-new ultra nano-sized digital servo from Hitec! Let’s take a closer look and see what Feldi has to show us!

The show is All of THAT, and yes we do it all the time.

SparkFun THAT 1206 InGenius Breakout

SparkFun THAT 1646 OutSmarts Breakout


The THAT 1206 InGenius and 1646 OutSmarts breakout boards offer an easy solution to adding balanced audio inputs and outputs to your circuits. The THAT InGenius and OutSmarts technologies are designed for high-grade analog audio transmission and reception. They offer low distortion and high common mode rejection in real-world audio applications.

These two breakouts perform mirror-image signal conversion. The 1646 OutSmarts is an unbalanced-to-balanced output driver, and the 1206 InGenius is a balanced-to-unbalanced input receiver.

The breakout boards combine the THAT IC, supporting components and a ¼" TRS socket. They make it easy to use the input and output drivers on breadboards and in projects.

Servo - Hitec HS-5035HD (Ultra Nano Size)


This is one of the smallest servos we carry, but don’t let its size fool you! The HS-5035HD is the digital version of the popular HS-35HD and is destined to become a fan favorite! Equipped with a fully programmable digital circuit, Metal Karbonite gear train and long-life potentiometer, the HS-5035HD provides heavy-hitting performance in a lightweight package. The HS-5035HD is able to take in 4.8 volts and deliver 11.11 oz-in of maximum torque at 0.1 sec/60°, and this guy is only about the size of a penny!

That’s all for today, folks! Be sure to check back in with us next Friday for even more new products. We are pretty sure you are going to want to see what we have in store for you next week! Thanks for stopping by!

comments | comment feed

How to make a Balboa robot balance, part 3: encoders

via Pololu Blog

This is the third post in a series about how to make a Balboa 32U4 robot balance. Last week I talked about inertial sensors, especially the gyro. In this post I will talk about the Balboa’s built-in encoders, which allow accurate measurements of motor speed and distance.

[See also: Part 1: selecting mechanical parts, Part 2: inertial sensors, Part 4: a balancing algorithm, or Part 5: popping up and driving around.]

To get your Balboa to balance, you will soon need to create a balancing algorithm, a program that takes sensor input and computes the appropriate motor speed settings to keep the robot upright. So far our only inputs, both from the gyro, are the rate of rotation and current angle of the robot. These are not quite enough to make a good balancer. To see why, suppose that your program tries to balance by holding the angle at a constant 90°. If your definition of 90° is even slightly off-balance, the robot will need to keep accelerating, driving faster and faster to maintain it, until it reaches top speed or hits an obstacle. You might be able to account for this by using the motor output settings themselves as an input to your algorithm, but this is difficult, especially at the low speeds used for balancing. Also, even if you can avoid accelerating, your robot will gradually drift in one direction or the other. The Balboa’s encoders are valuable additional sensor inputs that allow you to measure how fast the wheels are actually turning, so you can directly control acceleration and drift. As a bonus, encoders are great for driving straight, precision turns, and navigation.

The encoders consist of a magnetic disc attached to the shaft of each motor, and two Hall effect sensors on the PCB directly under each disc:

Each disc is (invisibly) magnetized with three north poles and three south poles; during a rotation of the motor shaft, each of the six poles rotates across the two sensors, giving 12 “counts” per revolution. Each rotation of the wheels then gives a number of counts that is 12 multiplied by the gear ratio. These counts are the basic units of your encoder inputs, so it’s a good idea to learn what they correspond to in terms of actual distance traveled. For a gear ratio ``G`` and wheels with diameter ``D``, the distance per count is `` pi D // ( 12 * G )``. Using the 80mm wheels and the gear ratio table from my post about selecting mechanical parts, you can compute the distance per encoder count (in mm):

30:1 50:1 75:1
49:17 0.24 0.14 0.10
47:19 0.28 0.16 0.11
45:21 0.33 0.19 0.13
43:23 0.38 0.22 0.15
41:25 0.43 0.25 0.17

The values are all fractions of a millimeter, so for speeds of 1 m/s or more, you need to be able to read thousands of counts per second. Microcontrollers like the Balboa’s ATmega32U4 are great at this kind of task because of their support for interrupts, which are special functions in your code that execute immediately when a specified event occurs, suspending the rest of your code while they run. The Balboa 32U4 Arduino library includes interrupts that handle encoder counts automatically; to see the details, take a look at Balboa32U4Encoders.cpp and also read the section on encoders in the Balboa User’s Guide.

Since the library takes care of the counting, using encoders in a sketch is pretty easy. You just need to declare a Balboa32U4Encoders object and call its methods getCountsLeft() and getCountsRight() whenever you want to know the number of counts that have accumulated. However, there is a small complication: for efficiency, these methods return 16-bit unsigned integers, so with a maximum value of 65,535, they will overflow after your Balboa drives forward a few tens of meters. You should hope to eventually make it farther than that, so let’s look at how to save your encoder counts in nearly overflow-proof 32-bit integers. Luckily, there is another pair of functions we can use: getCountsAndResetLeft() and getCountsAndResetRight() set the internal number of accumulated counts to zero each time you check them, and they return the count as a signed integer that you can add to your own 32-bit variables distanceLeft and distanceRight:

Balboa32U4Encoders encoders;
int32_t distanceLeft;
int32_t speedLeft;
int32_t distanceRight;
int32_t speedRight;

void integrateEncoders()
  speedLeft = encoders.getCountsAndResetLeft();
  distanceLeft += speedLeft;

  speedRight = encoders.getCountsAndResetRight();
  distanceRight += speedRight;

As a side benefit, the change in encoder counts can be used as a measure of speed, so we store that as well, in the variables speedLeft and speedRight. Note these will only be a good measure of speed if integrateEncoders() is called on a regular period, with enough time between calls to accumulate at least a few counts. For example, if we call it every 10 ms, on a Balboa with 80 mm wheels, the 45:21 plastic gears, and 50:1 gearmotors, at 1 m/s we will measure a speed of ``1 text( m/s) * 0.01 text( s) // (0.19 text( mm/count)) ~~ 53``.

We now have four new inputs available for our balancing algorithm, which I will talk about in my next post.

Continue reading with Part 4: a balancing algorithm.

Robot Arm From Recyclables

via hardware – Hackaday

A robot assistant would make the lives of many much easier. Luckily, it’s possible to make one of your own with few fancy materials. The [] team demonstrates this by building a robot arm out of recyclables!

With the exception of the electronics — an Arduino, a trio of servo motors, and a joystick — the arm is made almost completely out of salvaged recyclables: scrap wood, a plastic bottle, bits of plastic string and a spring. Oh, and — demonstrating yet another use for those multi-talented tubers — a potato acts as a counterweight.

Instead of using screws or glue, these hackers used string made from a plastic bottle as a form of heat shrink wrap to bind the parts of the arm together. The gripper has only one pivoting claw for greater strength, and the spring snaps it open once released. Behold: your tea-bag dunking assistant.

Code for the project is available to download from their site. Given this straightforward tutorial, it’s hard to find a reason NOT to embark on building your first robot arm — if you haven’t already begun.

We at Hackaday love seeing projects that strive to reuse materials in inventive ways. That said, you needn’t rely on a shiny new Arduino for this robot arm. If you have an aging palm pilot kicking around, that will also do the trick.

Filed under: Arduino Hacks, hardware, robots hacks

Line-following robot and mini-sumo main board from tdrobó

via Pololu Blog

One of our distributors in Colombia, tdrobó, has developed a line-following robot kit and a mini-sumo main board kit.

The first kit includes everything you need to build a sleek line-following robot. It uses an Arduino-compatible A-Star 32U4 Micro as the main controller. It also uses a DRV8833 Dual Motor Driver Carrier, two Pololu micro metal gearmotors, brackets, and a 3/8″ ball caster.

The second kit is also based on the A-Star 32U4 Micro and DRV8833 carrier, and it includes much of the electronics needed to build a custom mini-sumo robot, including a buzzer, a voltage regulator, and an IR receiver for controlling it with a TV remote. It has two DRV8833 carriers, each with their channels paralleled to drive a total of two motors. There are connection points for 7 digital sensors (up to 5 can be analog).

tdrobó’s mini-sumo main board kit.

For more information (in Spanish), see the line-following robot kit and a mini-sumo main board product pages.

When SparkX builds a safe cracking robot, everyone wins!

via SparkFun Electronics Blog Posts

Cracked safe

Empty, but still cool to watch

An automatic safe cracker was something we had discussed on the very first day of SparkX, and it was really great to see it come to fruition. Thanks to all who watched and commented on our live stream!

We asked for you to take guesses, given very little information, on how long our bot would take to crack the safe, and also, what the combination would be. Whoever came the closest without going over (Price Is Right rules) would win a $100 Sparkfun gift certificate. Well, now that the dust has settled, and we’re still sitting here happily and a bit proudly staring at our open safe, we have found our winners. For time, with a guess of 00:30:05, our winner is TCRobotics. And for combination, with a guess of 12/76/53, the winner is GCF. Congratulations!

For those of you interested in the finer points of how we did what we did, we’ve added a tutorial on our entire process, which you can find here.

Thanks again for watching, and Happy Hacking!

comments | comment feed