Keywords

1 Introduction

Cable-driven parallel robots, from now on referred to as cable robots, are a class of parallel robots actuated by flexible cables instead of rigid members.

We will differentiate between two types of cable robots. Completely/redundantly restrained cable robots, where the number of cables \(m\) exceeds the degrees of freedom \(n\) in order to achieve full control; and a second type of cable robot: the suspended cable robots. Suspended cable robots rely on an external wrench to control the robot position and are most often seen as hanging structures.

The forward kinematics—obtaining platform pose from cable lengths—of parallel machines is a difficult problem. However, for the operation and for advanced control techniques of cable robots, a numerically stable and fast computation of the forward kinematics is needed. In practice, this is often achieved by using optimization algorithms.

In this paper an algorithm for completely restrained cable robots, based on combining neural networks with interval arithmetic, is introduced and tested. This combined approach offers greater computational speed than algorithms purely based on interval arithmetic, whilst maintaining strict confidence in the obtained solution.

2 Literature Review

Various methods to compute the forward kinematics of parallel manipulators already exist. In some specific cases the problem can be simplified due to specific geometrical traits, resulting in a set of algebraic descriptions which can easily be solved symbolically [3, 12]. Algebraic formulations have also been made for the general case, resulting in high-degree polynomials which are very difficult to solve [7].

Merlet introduced a numerically more stable approach for the general parallel machine using Interval Arithmetic [9].

These approaches stand in contrast to the iterative optimization techniques, which evaluate the inverse Kinematics repeatedly, to gain an increasingly accurate pose with each step. The computation time of such techniques is acceptable and has been successfully implemented for real-time execution on robot systems [10].

Suspended cable robots require additional considerations when evaluating the kinematics. Since the external wrench applied by gravity is an integral part to the robots structure, it needs to be taken into account when evaluating the robot’s pose. Recent publications discuss this static and dynamic coupling and propose algebraic solutions [2, 4]. Ghasemi has presented a successful implementation of neural networks to find the solution for a suspended cable robot [5].

2.1 Shortcomings of Existing Methods

Despite having a wide range of computational approaches to choose from, the evaluation of forward kinematics remains a challenge, especially when considering real time constraints on modern machines. Simplifying the problem through the selection of special geometries is not always a feasible step depending on the constraints of the robot considered.

Mathematically exact methods, which are capable of finding all possible solutions and using heuristics to select the right one, are not feasible for production machines due to numerical instabilities or excessive computation time. Interval arithmetic on the other hand yields certain guarantees due to its deterministic nature. Unfortunately, interval arithmetic routines are based on exhaustive search algorithms and typically do not perform in a real-time environment.

Faster iterative optimization algorithms, however, demand a good initial guess for the solution and do not guarantee convergence. This can have unexpected consequences and requires additional sub-routines to manage non-convergence, or even divergence from the solution.

Neural networks are computationally fast algorithms but also lack the capability of providing a guaranteed solution or any indication of confidence. Further, these networks need to be trained a-priori, consuming additional time and effort.

All approaches suffer under kinematic sensitivity [8]. This provides a measure of how numerically sensitive the poses are to changes in the cable lengths and an indication why some solutions are hard to find. Further discussion is out of scope for this paper.

2.2 Benefits of the Combined Approach

Using neural networks to provide a fast initial estimate for the solution and then applying an interval algorithm to the smaller search space, combines the strengths of these two methods. Unlike optimization algorithms interval analysis can easily differentiate between whether an exact solution can be found in the given bound, to a predetermined level of accuracy, or whether a solution is indeterminable. Even detecting singularities is plausible [9]. Neural Networks, once trained, provide a very fast evaluation with minimal computational effort.

It is this combination approach which enables a robust, but still relatively fast computational method.

3 Description of the Combination Approach

The cable-driven parallel robot IPAnema illustrated in Fig. 1, has eight cables and six degrees of freedom, making it redundantly restrained. The geometry is described using two coordinate systems, one for the platform \(\mathcal K _\mathcal{P }\) and one global coordinate system for the base \(\mathcal K _\mathcal{O }\). The vector notation describes the inverse kinematics for cable \(i\) as:

$$\begin{aligned} \Vert \mathbf a _i-\mathbf r -\mathbf R \mathbf b _i\Vert _{2} = l_i \quad \mathrm for \, i=1,\ldots ,m \end{aligned}$$
(1)

where \(\mathbf a _i,\mathbf b _i, \mathbf r \) are vectors describing attachment points and platform position, \(l_i\) is the length of the cable and \(\mathbf R \) the rotation matrix at a given pose.

The forward kinematics currently implemented in the IPAnema cable robot [10] uses a Levenberg-Marquardt (LM) algorithm to optimize the function

$$\begin{aligned} \varPsi _{i}\left( \mathbf l,r,R \right) = \left( \Vert \mathbf a _i-\mathbf r -\mathbf R \mathbf b _i\Vert _{2}\right) ^2 -l^{2}_{i}\quad \mathrm for \, i=1, \ldots ,m \end{aligned}$$
(2)

to finde the pose \(\mathbf r,R \) for a set of cable lengths \(l_i\).

For the interval algorithm a different parameterization, based on distance equations, is used. This parameterization focuses on finding the position of \(f\) linearly independent reference points in the global coordinate frame and hence the pose of the platform. These reference points on the platform were chosen to be cable attachment points and are chosen so that all other attachment points \(j\) are linearly dependent on these reference points \(k\). This relation in the coordinate system \(\mathcal K_P \) is described by

$$\begin{aligned} \mathbf b _j=\sum _k \mathbf C \mathbf b _k, \end{aligned}$$
(3)

where the conversion matrix \(\mathbf C \) is calculated offline.

Fig. 1
figure 1

IPAnema Robot with Geometrical Parameters: base vector \(\mathbf a _i\) and platform vector \(\mathbf b _i\)

Full size image

The equation sets describing the kinematics, which are solved by the interval algorithm are then as follows. The cable length for each reference point \(\left( x_k,y_k,z_k\right) \)

$$\begin{aligned} \left( x_k - A_k^x\right) ^2 + \left( y_k -A_k^y\right) ^2 + \left( z_k - A_k^z\right) ^2 = l_k^2 \quad \text {for } k\in {1,2,\ldots ,f}, \end{aligned}$$
(4)

the remaining cable lengths

$$\begin{aligned} \left( \sum _{k=1}^f\mathbf C x_k-A_j^x\right) ^2+\left( \sum _{k=1}^f\mathbf C x_k-A_j^y\right) ^2+\left( \sum _{k=1}^f\mathbf C x_k-A_j^z\right) ^2=l_j^2&\nonumber \\ \text {for } j\in {f+1,\ldots ,n}&\end{aligned}$$
(5)

and the distance between reference point pairs

$$\begin{aligned} \left( x_p - x_q\right) ^2 + \left( y_p-y_q\right) ^2+\left( z_p-z_q\right) ^2=\delta _{pq}^2 \quad \text {for } p,q\in {1,2,\ldots ,f},p\ne q. \end{aligned}$$
(6)

This parameterization is better suited for interval methods as it avoids overestimation of the interval bounds due to each variable being represented only once in each equation. It was found that this formulation of the forward kinematics problem was not beneficial for the iterative methods over an Euler Angle representation used to generate rotation matrix \(\mathbf R \) in Eqs. (1) and (2).

3.1 Neural Network

In the combination approach the pose of the platform is initially estimated by a set of neural networks. This greatly reduces the search space for the more time consuming interval algorithm. The neural network sets return a particular solution for the four reference point positions, whose error/uncertainty bounds define the initial search space of the interval algorithm.

The neural network was designed and implemented using the “Stuttgart Neural Network Simulator” (RSNNS) in the R statistical programming language [1]. The design is based on the multilayer perceptron (MLP), also used by Ghasemi [5]. In this case one neural network was used to determine the position \(\left( x,y,z\right) \) of a given reference point. Each neural network was built with four hidden layers containing 70 neurons each. Since the IPAnema cable robot has eight cables this results in a \(8\times 70\times 70\times 70\times 70\times 3\) MLP architecture.

The neural network was trained in a supervised approach with standard back-propagation, using default learning parameters of RSNNS. For a random pose the reference point positions and cable lengths are evaluated through the inverse kinematics (1). Then the artificial neural network calculates the reference point positions. The error residual sum of squares in the computed reference point positions is used to determine the weight adjustments of the individual neurons. One epoch repeats this process for every pose in a training set. A test set evaluates the performance of the neural network whose error is minimized over 800 epochs.

The full set of poses consists of 1,00,000 random poses in a workspace of \(6\times 5\times 4\) m in \(x,y,z\) and rotations in the range of \(\pm 20^\circ \) about each axis. 40,000 poses were used as a training set and the remaining 60,000 as a test set. Feature normalization was also applied for the cable lengths in the stated workspace.

Graphs in Fig. 2 show the results of a single network training. The histogram shows the distribution of the final absolute error of the test set. The maximum error determines the bounds of initial search space for the interval algorithm, \(\pm 0.02\) m. This speeds up the computation time. While interval analysis is a complex iterative procedure, successive operations necessary for each neuron will only be evaluated once.

Fig. 2
figure 2

Single neural network training results

Full size image

3.2 Interval Algorithm

The interval algorithm based on [9] resembles a bisection method. The workspace is divided into successively smaller boxes which are then evaluated against the parametric Eqs. (4–6) with interval arithmetic. A box is a 12 dimensional hyper-cube of the \((x,y,z)\) values of the four reference points. The starting box was based on the maximum error produced by the neural network test set. Interval arithmetic then determines whether a solution to the parametric equations exists within this box, does not exist, or cannot be determined. This branch and bound algorithm discards boxes containing no solution and continues to divide the rest, until a sufficiently small (specified by the desired accuracy) box without a solution is reached.

This is a deterministic and time consuming method to obtain a solution to the forward kinematics problem. Several techniques to speed up this process by reducing box sizes are implemented. One technique is evaluating for hull (or 2B) consistency as in constraint satisfaction problems as shown in [9]. Here the constraints of a single variable in the parametric equations are shrunk by those defined for the other variables. This can be repeated indefinitely, but tests showed that once the improvement was below \(25\,\%\) it was more efficient to return to the branch and bound.

Another very effective method to reduce box size was the Interval-Gauss-Seidel method [11], which not only reduces the hyper-volume of a box, but also mitigates effects of solution clustering. Here the variable bounds are also shrunk individually using an iterative technique by applying the formula of a classic linear equation system to this variable.

These methods make the computation more efficient, but not to the same scale as the initial guess by the neural network.

4 Performance Evaluation

The algorithms for solving the forward kinematics are implemented in C++. This enables the use of SIMD instruction sets on an x64 architecture to provide a significant increase in speed for interval calculations and is discussed in detail by [6]. The processor used for testing was an Intel i7–2600 K with 3.40 GHz.

Table 1 shows the results of a quick comparative benchmark of three algorithms implemented under identical conditions. A random pose list of 1000 poses, with corresponding cable lengths was generated using Eq. (1). Poses were in a \(4\times 4\times 3\) m box in the workspace and described by a rotation of \(-10^\circ \) to \(10^\circ \) for each Euler Angle. Each algorithm calculated every pose to an accuracy of \(0.00001\) m.

Table 1 Computation time tested on IPAnema geometry
Full size table

The computational speed of the Interval Algorithm is greatly increased through the use of neural networks. The average computation time decreased by more than a factor of 200, the number of boxes even more. This makes the approach more real-time feasible.

Maximum time to solution could not be evaluated for the LM optimization as it was too fast for the timer resolution, so the average was taken from the total time over 1,000 iterations. Keeping in mind that the initial pose estimate is tailored for this cable robot geometry, the optimization algorithm computes extremely fast.

Neural networks do need to be retaught for significant geometry changes, but have no limitations as to the type of geometry to solve. Further, the interval algorithm still can provide certainty of the solution and guarantee convergence, which the optimization cannot.

5 Conclusions

It was shown that combining neural networks with the standard implementation of interval arithmetic to solve the forward kinematics of cable robots provides significant decrease in computation time. This enables a more real-time feasible implementation, while retaining strengths of the interval methods. While the speed does not surpass that of highly optimized LM iterative solutions, it provides a method with guaranteed convergence, and the possibility of finding numerous poses. It is a viable alternative for actual real-time controllers.

Improvements can still be made. The neural network training algorithm could be optimized to provide a more accurate initial guess. Several steps in the interval algorithm could be taken to optimize the switching between the branch and bound, consistency checks, and the Interval-Gauss-Seidel method. This is difficult to optimize for the general case.

The teaching of neural networks is still an issue, as it diminishes the ease of changing geometric configuration. However, slight configuration changes still enable the neural network to converge enough for the interval algorithm to run at acceptable speeds. Further, the only requirement for teaching the networks is a working inverse kinematic implementation. This process can be heavily automated.

Problems of kinematic sensitivity are not addressed by either of these algorithms, but are still subject of ongoing research.