This repository is dedicated to develop functions for automatic computations for designing robotic manipulators.
The package can be installed from PyPI by using the following command via terminal.
pip install acrod
The topological information of a robot is to be specified by using its robot-topology matrix, as defined here. For a planar 2R serial manipulator (as shown in the above figure), the robot topology matrix is given by
$$\left[\begin{matrix} 9 & 1 & 0 \\ 1 & 9 & 1 \\ 0 & 1 & 9 \end{matrix}\right]$$
The corresponding Jacobian function can be formulated as follows.
Firstly, the required functions are imported as shown below.
from acrod.jacobian import Jacobian
from numpy import array
The robot-topology matrix for 3R planar serial manipulator is defined and jacobian information is processed via the imported jacobian class as follows.
M = array(
[[9, 1, 0],
[1, 9, 1],
[0, 1, 9]]
)
jac = Jacobian(M, robot_type = 'planar')
Jacobian function is generated as shown below.
jacobian_function = jac.get_jacobian_function()
In the process of generating the above jacobian function, other attributes of the jacobian object also are updated. Symbolic Jacobian matrices can be extracted from the attributes. Since this is a serial robot, the matrix $J_a$ itself would be the Jacobian matrix of the manipulator. The matrix $J_a$ is extracted from Ja attribute of the jacobian object as follows.
symbolic_jacobian = jac.Ja
symbolic_jacobian
In an ipynb file of JupyterLab, the above code would produce the following output.
$$\left[\begin{matrix}- a_{y} + r_{(1,2)y} & - a_{y} + r_{(2,3)y} \\ a_{x} - r_{(1,2)x} & a_{x} - r_{(2,3)x} \\ 1 & 1\end{matrix}\right]$$
The above Jacobian is based on the notations defined and described here.
Active joint velocities, in the corresponding order, can be viewed by running the following lines.
active_joint_velocities = jac.active_joint_velocities_symbolic
active_joint_velocities
In an ipynb file of JupyterLab, the above code would produce the following output.
$$\left[\begin{matrix}\dot{\theta}_{(1,2)} \\ \dot{\theta}_{(2,3)}\end{matrix}\right]$$
Robot dimensional parameters can be viewed by running the below line.
robot_dimensional_parameters = jac.parameters_symbolic
robot_dimensional_parameters
In an ipynb file of JupyterLab, the above code would produce the following output.
$$\left[\begin{matrix}r_{(1,2)x} \\ r_{(1,2)y} \\ r_{(2,3)x} \\ r_{(2,3)y}\end{matrix}\right]$$
Robot end-effector parameters can be viewed by running the below line.
robot_endeffector_parameters = jac.endeffector_variables_symbolic
robot_endeffector_parameters
In an ipynb file of JupyterLab, the above code would produce the following output.
$$\left[\begin{matrix}a_{x} \\ a_{y}\end{matrix}\right]$$
For the given set of dimensional parameters of the robot, the numerical Jacobian can be computed as follows. Firstly, we need to gather the configuration parameters in Python list format, in a particular order. The robot dimensional parameters from jac.parameters_symbolic are found (as shown earlier) to be in the order of $r_{(1,2)x}$, $r_{(1,2)y}$, $r_{(2,3)x}$ and $r_{(2,3)y}$. Hence the configuration parameters are to be supplied in the same order, as a list. Thus, the computation can be performed as shown below.
end_effector_point = [1,2]
configuration_parameters = [3,4,5,6]
jacobian_at_the_given_configuration = jacobian_function(end_effector_point, configuration_parameters)
jacobian_at_the_given_configuration
The output produced by running the above code, is shown below.
array([[ 2, 4],
[-2, -4],
[ 1, 1]])
Mathematical concepts behind formulating the Jacobian can be found here.
For dimensional synthesis, at least a performance parameter is required. One commonly used performance parameter in dimensional synthesis is the condition number. From the above Jacobian function, the condition number can be found by computing the ratio of maximum singular value and minimum singular value. This condition number has the bounds $(1,\infty)$. When the condition number is 1, that signifies the best performance in the context of condition number. The computation of condition number from a given Jacobian can be achieved by the code shown below:
from numpy.linalg import svd
def condition_number_func(jacobian_matrix):
_, singular_values, _ = svd(jacobian_matrix)
condition_number = singular_values.max()/singular_values.min()
return condition_number
For reference if we take the joint at the fixed link to be at the origin, the dimensional synthesis for optimal performance around the end-effector point $\textbf{a}=\hat{i}+2\hat{j}$ can be performed by the code shown below:
from scipy.optimize import minimize
from numpy import hstack, ones
end_effector_point = [1,2]
base_reference_point = [0,0]
r12 = base_reference_point
jac_fun = lambda y: jacobian_function(end_effector_point, hstack((base_reference_point,y)))
condition_number = lambda z: condition_number_func(jac_fun(z))
initial_guess = ones(len(jac.parameters)-len(base_reference_point))
res = minimize(condition_number, initial_guess)
r23 = res.x
The link lengths $l_2$ and $l_3$ are given by $l_2 = \lVert \textbf{r}_{12}-\textbf{r}_{23} \rVert$ and $l_3 = \lVert\textbf{r}_{23}-\textbf{a}\rVert$. By using the code below, the link lengths of 2R robot can be computed.
from numpy.linalg import norm
l2 = norm(r23-r12)
l3 = norm(r23-end_effector_point)
print(l2,l3,res.fun)
Output:
3.4641016153289317 2.236067976155377 1.0000000007904777
The above output shows that for $l_2=3.464$ and $l_3=2.236$, the robot has the condition number approximately equal to $1.0$, which signifies optimal performance.
Some examples (along with their mathematical derivations) can be found here.
For full documentation, visit the documentation page here.
FAQs
Automatic Computation for Robot Design (ACRoD)
We found that acrod demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
PyPI confirms no security flaws were exploited in the Ultralytics supply chain attack and highlights improvements for safer package publishing.
Security News
Research
The Socket Research Team breaks down a malicious wrapper package that uses obfuscation to harvest credentials and exfiltrate sensitive data.
Research
Security News
Attackers used a malicious npm package typosquatting a popular ESLint plugin to steal sensitive data, execute commands, and exploit developer systems.