6DOF load cells using strain gauges

I’ve become interested recently though an honours project by the construction of six degree of freedom load cells using strain gauges. In many cases I believe this information is unpublished since the load cell manufacturers have no desire or need to publish such information. There are some published on various designs, however, and they vary considerably in terms of mechanical design and strain gauge arrangement.

I’ve heard that high-end load cells use up to 32 strain gauges to resolve the six forces and torques. In such arrangements, four or more strain gauges are placed in groups carefully designed to reject off-axis loads. Six directions and four per group make 24, which is the number used by Joo et al. (2002), whose device consists of a steel rectangular shaft with multiple cut-outs to provide mobility for the various strain gauge groups.

A simpler mechanical system that also used 24 strain gauges was developed here at The University of Adelaide, described by Dr Carl Howard in his thesis ‘Active isolation of machinery vibration from flexible structures’.

Still, using 24 strain gauges to measure just 6 output signals could be considered overkill. Bayo and Stubbe (1989) investigated a truss arrangement on the assumption that truss elements can only undergo one main mechanism of deformation, axial strain, and therefore would be much easier to instrument using strain gauges. Their design uses only eight but the truss does not look easy to machine — except now with 3D printing this may no longer be an issue.

Finally, the more mathematically-minded rather than mechanical-minded may question why more than six strain gauges are needed anyway. Surely with a particular geometry and understanding of the strain kinematics, six load signals could be calculated from six strain measurements. Indeed, this idea was investigated by Dai and Kerr (2000) using a Steward platform (also known as a hexapod), in which the ‘legs’ of the platform were tension cables mounted to cantilevered strain gauge beams.

I’m not aware of any work that compares these various approaches for different requirements. The truss-like structures seem promising, but are they structurally rigid enough for dynamic loading situations? It’s intuitive that the devices with fewer strain gauges could suffer from more cross-axis contamination, but if the system is well characterised perhaps that can be well accounted for. The savings in design complexity, cost of strain gauges and the cost associated electronics certainly deserve the comparison.

Bayo and Stubbe (1989) “Six-axis force sensor evaluation and a new type of optimal frame truss design for robotic applications.” Journal of Robotic Systems 6. DOI: 10.1002/rob.4620060206

Dai and Kerr (2000) “A six-component contact force measurement device based on the Stewart platform.” Proceedings of the Institution of Mechanical Engineers, Part C: Journal of Mechanical Engineering 214. DOI: 10.1243/0954406001523696

J.W Joo, K.S Na, D.I Kang (2002) “Design and evaluation of a six-component load cell.” Measurement 32. DOI: 10.1016/S0263-2241(02)00002-7


“Locomotion of Mexican jumping beans”

You know these people must absolutely love their research. Abstract:

The Mexican jumping bean, Laspeyresia saltitans , consists of a hollow seed housing a moth larva. Heating by the sun induces movements by the larva which appear as rolls, jumps and flips by the bean. In this combined experimental, numerical and robotic study, we investigate this unique means of rolling locomotion. Time-lapse videography is used to record bean trajectories across a series of terrain types, including one-dimensional channels and planar surfaces of varying inclination. We find that the shell encumbers the larva’s locomotion, decreasing its speed on flat surfaces by threefold. We also observe that the two-dimensional search algorithm of the bean resembles the run-and-tumble search of bacteria. We test this search algorithm using both an agent-based simulation and a wheeled Scribbler robot. The algorithm succeeds in propelling the robot away from regions of high temperature and may have application in biomimetic micro-scale navigation systems.


Forces between cylindrical magnets

Deriving an equation to calculate the forces between cylindrical magnets is harder than for cuboid magnets (for which a closed form solution was first published in 1984).

Most recently, Ravaud et al. published (2010) an closed form expression for the force between coaxial magnetic cylinders, for which I’ve currently a paper in publication with a much simpler equation. You can download my code for implementing this in my repository of magnet code; the Matlab example is ‘examples/ravaud-cylmag.m’ and the Mathematica example has extension ‘.nb’ with the same name.

The force equation for coaxial magnets contains elliptic integrals, and when analysing the system for eccentric displacements in the radial direction the integral becomes, as far as I know, not possible to solve tractably. I’m aware of two different approaches for calculating the forces for these cases. The first is by Nagaraj in a somewhat-elusive paper from 1988 who simplifies the necessary integrals until only a double-integral that can be evaluated numerically. (A numerical evaluation of a nicely-behaved integral is typically around an order of magnitude slower than if a closed form solution is known.)

A more recent analysis of eccentric magnetic cylinder forces was published in 2009 by Vokoun et al., and to be honest their approach is a little alien to me; I haven’t looked into their maths very much and I don’t know if the implementation would be harder and/or more efficient than the approach used by Nagaraj.

Implementations of these latter two papers would be very useful for us at the moment but I don’t have time to do it myself right now; I have some honours students who might step up to the plate. If so, I’ll add their code to the magcode repository; a common theme with all this code is that a reference implementation saves people so much time when they need to use the theory publicised by these authors.

The DOIs for the papers mentioned above are:

  • Akoun & Yonnet 1984: 10.1109/TMAG.1984.1063554
  • Ravaud 2010: 10.1109/TMAG.2010.2049026
  • Nagaraj 1988: 10.1080/10402008808981815
  • Vokoun 2009: 10.1016/j.jmmm.2009.07.030

Obtaining less ugly printed Nichols plots

I’m unexpectedly teaching a course in system dynamics and PID control at the moment. In this course there is a somewhat complex display called a Nichols Plot, in which the log magnitude of an open loop transfer function (i.e., a complex function) is plotted against its phase, overlaid against contours of magnitude and phase of the closed loop dynamics. It’s these contours that cause some grief.

Using the in-built commands in both Matlab and Mathematica (resp. nichols and NicholsPlot) produces quite useable interactive plots which can be queried and manipulated on-screen. Information can be selected and extracted by clicking and pointing, which is largely the intention of using these sorts of techniques.

But for generating course material (slides, assignments, exams) neither Matlab nor Mathematica offer sufficient (user-accessible) features to produce print-quality output. Here’s the best I can do in Matlab:

Matlab nex

Actually, disregarding the clipping problem at the bottom of this plot, this is pretty close to what I’d like to get. All I want is a way to control those contour lines — solid light grey looks far better especially near that 6dB contour — but my brief investigation into trying to customise them didn’t get me very far.

And Mathematica is worse: (to be fair, Wolfram only recently added these plots to Mathematica so they’re still immature)

Mma nex

Frankly, the Mathematica output is largely unusable in print; contour labels are only visible on mouse-hover, which obviously is not suitable here; furthermore, these contour lines don’t have any customisation options, and digging into Mathematica’s internals for customising plots is even less fun than in Matlab. Finally, the tick labels need work so they snap to ±n 90°, which is yet something else that needs manual adjustment.

Here’s my first attempt at something a little better in Mathematica. I’m out of time now to keep playing with it, but I think I’m on the right track; all that’s missing is to omit the regions within the 6dB circle, etc. And then do the same thing in Matlab.

Better nex


Magnetic field from a ‘thick coil/solenoid’ or ‘annular conductor’ or &c.

It happens that the integrals for calculating the magnetic field from all but the simplest objects (cuboid and cylindrical magnets) quickly become very difficult to solve, and in most cases closed-form solutions are not known. But reducing the integral required to a simpler form makes a huge difference in whether the result can be efficiently calculated on a computer.

I was amused recently when looking into the literature on the magnet field produced by ‘thick coils’ — i.e., a coil winding with many turns both long and deep — to find at least one new paper every decade for the last five consecutive decades on essentially the same work (by different authors). Here’s a probably incomplete list:

I haven’t implemented any of them to evaluate whether they give consistent results; my testing of Ravaud’s 2010 integral seems to give good results so I’m happy enough with his work for now. (I’m using his integral to — attempt to — derive the force produced on a permanent magnet in the vicinity of the coil, so I haven’t written code to reproduce his work exactly.)

What I find interesting is that although the work has been generalised to some extent over the years (see, e.g., the 1982 paper in which only arc segments are considered) in each case an equation is presented to calculate the magnetic field and presumably they all give identical results (they’re just solutions to a certain integral, after all). But in each case the papers were deemed worthy of publication. Hopefully new researchers looking for such works don’t miss the newer — and hopefully more useful — ones!

It’s worth noting that the 2010 paper links to a location with the claim that you can download their Mathematica code containing their equations. (Although I can’t see it there right now—hurrumph.) I think that the proliferation of code for the reproduction of such works is one of the best things we can do to accelerate the progress of the academic world. I’ll have more to say about this sort of thing in the future.


Recent work in humanoid robotics

Since I graduated from Mechatronic engineering oh so many years ago, I sometimes regret not going into the field of robotics. It’s certainly an area I like to keep an eye on, even if our school here isn’t very strong in the area.

Now that I’m also keeping a toe in the water for Sports Engineering, I’m trying to collect as many examples as I can that form a bridge between mechatronics and sports eng., as it’s that connection that I’m ostensibly occasionally employed to expound to the students.

Recently there have been a few papers published on the analysis of bipedal/humanoid-style robots; I’m not intending to review them here but I’ll be keeping them in mind for the future.


Elliptic integrals in Matlab

In recent work, I was taking some equations out of a paper and needed to calculate elliptic integrals with parameter ranges outside the traditional. I hence stumbled into a world that I was only vaguely aware of and resolved to spend some time writing some Matlab code to help out others in my situation.

I didn’t exactly get very far, but I’ve had a summer research student working on the problem for me—and while we haven’t completely solved the problem, I hope what we’ve written is of some use to some one. The short of it is that if you need to calculate the complete or incomplete elliptic integrals in Matlab, you might find our elliptic123 function here to be useful.

The usual elliptic integrals you see are the incomplete elliptic integrals of the first, second, and third kinds, respectively,F(\phi|m) , E(\phi|m) , and \Pi(n;\phi|m) . They are referred to as complete when \phi=\pi/2 and denoted as K(\phi) , E(\phi) , and \Pi(n; m) in turn.

Of these, Matlab can calculate only K(m) and E(m) for parameter range 0\le m\le 1 using its [K,E]=ellipke(m) function.

It turns out that calculating \Pi(n;m) is very easy, and it’s a trivial task to extend Matlab’s ellipke to calculate the third complete elliptic integral using the a faster-than-quadratically converging algorithm involving the arithmetic-geometric mean.

However, calculating the incomplete elliptic integrals is a far more difficult task, and for this purpose we based our work on Igor Moiseev’s work; again his functions assumed small input ranges with 0\le\phi\le\pi/2 , 0\le m\le1 and 0\le n\le 1 . Using transformation formulae from the DLMF and other sources, we we able to extend these parameter ranges, in some cases, to be without bound.

The function we have written to do this can be called as

[K, E] = elliptic123(m)
[K, E, PI] = elliptic123(m,n)

in the complete case, and

[F, E] = elliptic123(m,phi)
[F, E, PI] = elliptic123(m,phi,n)

in the incomplete case.

The idea of this elliptic123 function is to provide a wrapper around these transformation formulae and the standard methods for calculating the integrals, but we didn’t achieve our goal of entirely unrestricting the input parameter ranges, as in Mathematica. (See the help text of the function for the exact ranges where our transformations failed.)

I believe the only way around these limitations is to implement the Carlson symmetry elliptic integrals and use them to calculate the traditional elliptic integrals, as has been done by Fredrik Johansson for mpmath. His Python code could be ported to Matlab with too much difficulty, I think. Alas, I am out of time for this project.