In this case, you should use a technique called "inverse transformation technique". It will allow you to decompose the IK problem into wrist and shoulder and solve them separately. You can find this technique in the article tittle "Closed-form inverse kinematics position for humanoid robots"

Thank you. The paper has been very helpful

I am sure the closed-form solution technique suggested in previous answer must be useful. Another way of pursuing is through iterative process. This needs to take the reachability error (both position and orientation) as objective and any other limits as constraints. An optimization problem can be formed and easily solved using any classical optimization technique. The advantages are

1. the inverse kinematics solution with particular properties can be selected.

2. the technique can be easily implemented for even higher degrees of freedom and/or change in type of joint.

As the problem of motion planning and inverse kinematics have an exponential increase in complexity as the number of degrees of freedom increases, it is possible to use the method used for motion planning in high degree of freedom situations which is the potential field approach used usually for Androids.

See this Video for introduction to this topic (first 10 Minutes & last 15 Minutes):

https://www.youtube.com/watch?v=0yD3uBshJB0

Other than that I would recommend as the previous answer suggested a numerical approach based on optimization to solve such problem, also machine learning techniques might be helpful on those matter like in this paper:

http://www.sciencedirect.com/science/article/pii/S0921889014000360

or this paper:

http://www.scientific.net/AMM.273.119

Just to give you different view, you can blend with Task oriented type control and Inverse kinematics. I think you don't need to solve first three joint angles all the time. for the last three joints use task oriented control, or make some reachability criteria by distance of your target and the constraints you have. you will find some papers on  the individual topic I mentioned.    

Use The method of kinematic decoupling. ie consider the initial three links as seperate problem and your wrist as another problem. You can check the text book Robot Modeling and control by Mark W. Spong, Seth Hutchinson, and M. Vidyasagar.

In chapter 3 there is topic kinematic decoupling.

some time you may need to consider one extra rotation of the frame at the end of third link . It depends upon which euler angle representation you are using for your wrist.

Sorry to contradict your answer Mithum Poozhiyil, but in this particular case where the wrist is not spherical the conventional decoupling technique is not feasible. The reason for this is that the wrist orientation and position depend on the shoulder (which is spherical). The solution of this problem using a close-form solution will require to solve first the wrist and then the shoulder.  

Thanks for your suggestion. But I have solved similar kind of problem where two joints are coincided and the third joint is extended to some distance for the wrist.   

You should use matlab toolbox

I prefer the differential solution if the forward kinematics

x=f(q)

is known and a given trajectory xd(t)  should be tracked. From x=f(q)  we get the differential solution

dx=J*dq

where J is the Jacobian df/dq. From this we obtain the differential inverse

 dq=J-1*dx

A simple solution is obtained by

S J-1*dx=q

where dx=xd(t)-f(q). S means 'integration'

A little (weird) graphic  shows the principle:

Input is the desired trajectory. Together with the actual trajectory x we get a difference dx  and by using J-1 we obtain dq. Integration  using S  yields q.     From  f(q) (the forward kinematics) we get x which is fed back to the input.

 x_d----->O----dx--> J-1 --- dq----> S ---->O---q->

               - x                                                    I

                 I                                                     I

                 I

The method I developed in the following paper is very general and deals easily with joint and other constraints

M. Tarokh and M. Kim "Inverse Kinematics of 7 DOF Robots and Limbs by Decomposition and Approximation,", IEEE Trans. Robotics, No. 3, Vol 23, 2007, pp. 595-600.

Since the robot always exists at an allowed formation (configuration) before trying to move its tooltip (or multiple "tooltips" if you prefer for a grasp with multiple fingers) to where you request, you can calculate the resulting formation by stepwise transforming the original valid formation to the final one, trying to keep constraints all the way. I've suggested a reactive geometric approach to preserve constraints which trying to reach one or more goals (see http://www.slideshare.net/birbilis/IPROMSBirbilisAspragathosPPTnoSound20060709 and the earlier http://www.slideshare.net/birbilis/ARKBirbilisAspragathosPPT20040616a to get an idea of the concept). I had expanded this to graph (e.g. a grid) formations (apart from chains) and to angular constraints (between triplets of connected nodes), but never found the time to finetune and publish that stuff due to lack of some reseach project to fund the work (plus was busy with other software-related research like http://ClipFlair.net ;-)

The 6DOF serial-link robot inverse kinematics problem has 16 solutions, in general, and there have been several publications on how to derive a degree 16 polynomial for it.  This polynomial must be solved numerically, which can be done reliably by formulating it as an eigenvalue problem (see Companion Matrix on Wikipedia).  The first publication giving the reduction to a single polynomial is:

Lee, H.-Y., & Liang, C.-G. (1988). Displacement analysis of the general spatial 7-link 7R mechanism. Mechanism Machine Theory, 23 (3), 219–226.

(Don't let the title confuse you: inverse kinematics for a 6R open chain is equivalent to solving the motion of a 7R closed-loop chain.)

A simpler formulation of the same result is:

Raghavan, M., & Roth, B. (1993). Inverse kinematics of the general 6R manipulator and related linkages. ASME J. Mech. Design, 115 , 502–508.

And this last one is the basis for an efficient computational algorithm presented in:

D. Manocha & J. Canny, (1994) Efficient inverse kinematics for general 6R manipulators, IEEE Trans. Robotics & Automation, 10 (5), 648-657.

If you don't need real-time fast computation, i.e., you just want accurate answers in an easy way, try polynomial continuation.   A free software package, Bertini, does this problem and handles all kinds of systems of polynomial equations:

D. J. BATES, J. D. HAUENSTEIN,A. J. SOMMESE, AND C.W.WAMPLER, Bertini: Software for numerical algebraic geometry. Available at bertini.nd.edu.

This software and how to use it is described in:

Bates, Hauenstein, Sommese & Wampler, Numerically Solving Polynomial Systems with Bertini, SIAM Books, 2013.

In that book, for the 6R problem, see Example 5.2 (page 75) and Example 6.4 (page 109).  If you implement one of the fast methods, you might still want to use Bertini as an easy way to check that your implementation is correct.

As for joint limits, the usual approach is to find all solutions ignoring the limits and then just check which of these is inside the limits.

Good luck!

Nabanita:

If you already have your position equations for (e.g. X,Y,Z), inverse kinematics means you need an exact/numerical solution for your links/joints variables vector.

Try an algebraic way, through the pseudoinverse since your JAcobian matrix is kineamtically redundant (the number of control varaibles is larger than the number of workspace variables). A singular value decomposition may give a good approach to compute overtime the Jacobian peudoinverse.

try this open access article

http://www.sciencedirect.com/science/article/pii/S1877705813017499

Good luck!

nabanita:

you can produce data offline of position and end effector of robot and formulate a relation between position of joint and end effector of robot for this a neural network for example MLP is able to determine relation between joint position and end effector.

you can use neural toolbox in matlab to regulate parameter of neural network.