- Fast, accurate motion control for shape memory alloy (SMA) actuators
- Condition number of the joint-space inertia matrix
- Efficient factorization of joint-space inertia matrices with branch-induced sparsity
- Motion/force control theory and experiments
- Humanoid walking skills

This is bad news for anyone wishing to simulate or control a rigid-body system with a large number of bodies. Simulators suffer a loss of efficiency and accuracy, while control systems must cope with a highly sensitive plant with a lot of fast modes. Fortunately, the picture is not this bad for every mechanism. Unbranched chains of identical bodies appears to be the worst case; and the usual definition of matrix condition number (ratio of largest and smallest singular values) overestimates the true scale of the problem in some cases. I have written one paper on this work (see publications list), and I am continuing to study the problem.

The term kinematic
tree describes a rigid-body system without kinematic loops.
The joint-space inertia matrix (JSIM) of a kinematic tree posesses a
sparsity pattern that is determined by the branches in the kinematic
tree. In other words, branches force certain elements of the JSIM
to zero. It turns out that we can exploit this sparsity to reduce both
the cost of factorizing the JSIM, and the cost of back-substitution.
It can be done by a very simple algorithm that has almost no overheads.
The reduction in factorization cost can be dramatic, and is enough to bring
O(n^{3})
algorithms back into contention with O(n) algorithms for systems as
complex as a humanoid robot. This work is being written up.

[Link to WAM page eventually]

I have developed a new mathematical model of frictionless rigid-body contact, for the general case. In particular, it describes contact between bodies that are already constrained by some other mechanism. This kind of contact is very common. For example, it occurs whenever a robot with fewer than 6 DoF (or a part carried by such a robot) comes into contact with the environment. The new model also encompasses redundancy, multiple contacts and dynamic decoupling. It is highly compatible with Prof. Khatib's theory of dynamically consistent generalized inverses, and it succeeds in putting both the Jacobian and its dynamically consistent inverse into canonical form.

It makes several predictions about dynamic decoupling between the force-controlled subsystem and the motion-controlled subsystem, which are worth testing on a real robot. We have begun to set up an experiment to do this. [Link to WAM page eventually].

See the publications list for relevant publications.

This project is still on the drawing board, waiting for a research grant to materialize. If it goes ahead, it will include theory, simulations and experiments aimed at creating a body of knowledge on how to implement variety in complex motion. Although humanoids can walk already, they do so with a narrow repertoire of walking styles, and typically require a carefully controlled environment. They also have difficulty in switching from one behaviour to another, and in combining behaviours (e.g. walking while carrying or pushing something). The basic problem is that we don't yet have an adequate understanding of complex motion, and are therefore not yet in a position to create good motion controllers.

The objective is to create an algorithm that will calculate the
forward dynamics of a large system of rigid bodies very quickly on a
parallel computer. I have developed an algorithm that solves this
problem by a recursive divide-and-conquer technique: the given
rigid-body system is cut into two subsystems, the dynamics of each
subsystem is worked out *in parallel*
(by recursive application of the divide-and-conquer algorithm), and the
equations of the original system are worked out from the dynamics of the
two subsystems.

The result is an algorithm that takes *O*(log(*N*))
elapsed time to calculate the dynamics of a system containing *N*
rigid bodies on a parallel computer with *O*(*N*)
processors. The new algorithm is faster than other published
algorithms, but there is a snag: its numerical accuracy is poor compared
with the best serial algorithms. To be fair, the accuracies of
the other parallel algorithms have never been measured, so it is
entirely possible that they are no better, and perhaps even worse, than
the new divide-and-conquer algorithm.

This work has now been published (see publications list). All that remains to be done is to implement and test the closed-loop version (which has never been tested), and investigate the numerical accuracy problem.

The Constraint Force (CF) algorithm developed by Dr. Fijany et al.
was the first published dynamics algorithm to achieve *O*(log(*N*))
time complexity for a system with *N* rigid bodies on a parallel
computer with *O*(*N*) processors. The original version was
applicable only to systems in which the bodies were connected together
in an unbranched chain, using a restricted set of joint types; but we
have developed a new version that overcomes these restrictions.

Perhaps more important than the algorithm itself, is the technique used to derive it. I called it the change-of-basis technique, but it is really a general method for the mathematical analysis of constraints in a vector space and its dual. I used it subsequently to develop a new model of rigid-body contact, and to argue for duality in screw theory.

This work has now been published (see publications list), and the project is completed.