10
Start CLion from a commandline with your sourced ROS workspace (i.e. after calling source devel/setup.bash)
Open a project's CMakeLists.txt, and tell it to open it as a project rather than as a file.
That's it, you've got your workspace integrated :)
Debugging:
Debugging built files (nodes which you run through rosrun) is easy, you just normally run them ...
6
I agree with SteveO that there is nothing wrong with reinventing the wheel if you want to learn about wheels. And for a single application, 4 DoF arm, the IK is probably not too hard.
But I feel like I should mention that most of the kinematics libraries out there are mostly targeted towards Linux. And as such, probably not too hard to compile from ...
6
Integrating CLion with ROS is actually straight forward and works out of the box if one knows how to do it:
With your console, go into your ROS workspace and source the respective setup.bash file.
Go to the src directory of your workspace.
Start CLion from the console from your src directory.
Close any open projects in CLion and select Import Project from ...
5
It is rather straightforward to implement inverse kinematics for a particular manipulator in C++. Of course, you need to begin with the inverse kinematic equations themselves. Putting those into code will only involve a few trigonometric functions such as acos, asin, and atan2 (use atan2 instead of atan), and probably a couple of square and square root ...
4
PCL has a nice C++ templated RANSAC library which can solve your problem.
If you feel, PCL is too big of a dependency, then using umeyama function in Eigen's geometry module is probably the easiest way towards a working solution for your problem.
4
The best way to understand forward and inverse kinematics is to write a library for its own. A good starting point is to implement Cyclic Coordinate Descent.
So called "ready-to-run" librarys like OpenRave or OMPL have an extensive C++ tutorial section too but are notorius difficult to install. Most of them only run under linux, and are not even part of ...
4
If you make a career of robotics, you will come in contact with a lot of languages, a lot of libraries, and a lot of systems.
The more you know about the fundamentals, the easier it will be to adjust to something new. Likewise, if you focus your learning on whatever project or context is relevant to you at any given moment, it's more likely to stick with ...
4
At first, I did not go trough your code to check for errors in the formulas but from a high level perspective this seems ok. Therefore, your position controller is fine.
What you lack is a lowlevel controller for the PWM signal.
This controller should take the error of w_l - e.g. e_w_l - and w_r and provide a duty cycle accordingly.
For that you should ...
4
Robotics is a mixture of things like mechanical engineering, electronics engineering and software engineering! Knowing C++ is a big head start in this area! Because I strongly believe that amongst all three engineering categories software is the one thing you will spend the most time on when developing an autonomous robot.
So to start, learn computer-aided ...
3
It is a bit hard to know the exact cause of the error without having the (RobWork), I tried to install it following the link your provided, but I ran into some problems and I don't have the time to fix them at the moment. But I can point you to some issues that might be the source of your problem:
The transform method you are given in this code doesn't have ...
3
Given a desired pose:
$$T^{desired} = \begin{bmatrix}
s_x&n_x&a_x&P_x\\
s_y&n_y&a_y&P_y\\
s_z&n_z&a_z&P_z\\
0& 0& 0& 1
\end{bmatrix}$$
we know that this is given as follows:
$$T^{desired} = {}^{0}T_{1}{}^{1}T_{2}{}^{2}T_{3}{}^{3}T_{4}{}^{4}...
3
Your Jacobian-based approach is great for velocity control, or when the manipulator is close to the original point. But remember, the Jacobian only gives a first-order approximation to the manipulator's motion. With the highly nonlinear kinematics of manipulators, accuracy will vary throughout the workspace, and will decrease as the step size between the ...
3
I have a library called grl which integrates control of a KUKA iiwa in C++.
Right now the most reliable mechanism I've found for control is to receive state over FRI, then send state via Java. All the tools necessary to do this are integrated into grl.
While I've been able to receive state over FRI nicely, sending FRI commands so the robot drives reliably ...
3
What you are looking for is called serialization. Serialization is the process of creating a string (a serial stream of data) (not necessarily NUL-terminated) from arbitrary data.
The issue serialization addresses is the fact that the same data are represented in different computers differently. For example, take this struct:
struct A
{
unsigned int x;
...
3
I experimented a bit and here's what I think happens.
When you run
$ rostopic echo /questions
The /questions topic doesn't exist before you run the program. Maybe you cheat it by first running your programming, running this command and then running your program again, but this assertion is still true. So at the point when you run your program, rostopic is ...
3
Beaglebone USB
When you plug a USB cable between the USB B plug of the Arduino Uno and the USB A plug of the Beaglebone Black, the Beaglebone should be able to talk and listen to it the same way any other Linux distribution talks and listens to any other CDC class USB peripheral.
On the Beaglebone, a CDC class USB peripheral can be read an written to ...
3
To expand on Alexandre's answer:
Controlling the arm with the Jacobian along an end-effector trajectory is one way to do it. However, this will not give you obstacle avoidance. Although you could manually check for collisions at each time step, but i imagine this could get ugly. Additionally, this is a gradient technique, so you will be constrained to the ...
3
According to the Arduino reference for Servo.attach( ), you should be using pins 9 and 10, not 0 and 1.
Note that in Arduino 0016 and earlier, the Servo library supports only servos on only two pins: 9 and 10.
Verify that you are setting the proper pin number in code. Specifically, look at these lines in your originally-posted code:
void setup()
{
...
3
I rewrote your program a bit. Not tested since I have no servos.
#include <Servo.h>
Servo ULF; // Upper left front servo
Servo LLF; // Lower left front servo
byte index = 0;
int commandnum=1;
int steps = 0; // position of LLF servo
int partnum = 0; // unused for now
String command = ""; // the command we're building
char in; // ...
3
If you are already using Qt, then Q3 3D would be an obviuos choice for 3D representations. Gaming engines like Unity (C#/JavaScript) or the Unreal Engine (C++) are also a suitable choice for representing robots in 3D. You will find plenty of exmples like this.
Using directly OpenGL is also an option, but if you want anything else then just simple 3D ...
3
There are a few dimensions to being a roboticist:
is knowledge of theory about robot perception (understanding the world through sensors such as cameras, signal processing and machine learning), planning(how the robot should move) and action (how things move in space, kinematics, dynamics, control theory, reinforcement learning etc.). There are a lot of ...
2
It's python but easy to install: https://learn.adafruit.com/setting-up-io-python-library-on-beaglebone-black/pwm. Otherwise you can fopen files in the device tree and write to them, or you can open /dev/mem and directly access the registers for the PWM drivers.
I strongly recommend using the first method it is far easier than the third and basically the ...
2
The library call could be as simple as these two OpenRave Python lines:
robot.GetController().SetPath(traj)
robot.WaitForController(0)
Of course the types would have to match and all that. You would also have to write a controller plugin, which I have heard can be quite a bit of work. (These are just Python bindings for the C++ API, but I am not familiar ...
2
Cross post on YARP Q&A channel:
https://github.com/robotology/QA/issues/54
2
You need real camera synchronization which means using cameras that both have external trigger capability (it is like the "remote shutter" on consumer/DSLRs). What you do is feed a common trigger signal to both cameras and sync them like that down to the sub-ms level (the accuracy largely depends on the camera HW but is usually very good, usually in us).
...
2
Some very general advice.
My first impression from your question is that you are struggling with the fact that no hardware provides infinite resources. You can either slow down your control loops or look for better hardware (which may not exist).
If your control has nested loops, then run each one a slow as possible. Are you controlling position at 20kHz? ...
2
I haven't used it personally (yet; it's only a matter of time), but I believe the Rigid Body Dynamics Library is what you're looking for - efficient forward and inverse kinematics.
I did a lot of work with the underlying math behind that library, and even wound up (creating my account here to) asking a couple questions about it, one of which was answered ...
2
In this situation, you probably shouldn't use a Kalman filter for "filling" in the gaps. Typically, you use a Kalman filter (or Bayes filter etc...) to fuse information from different sources.
In your case, you have are using SLAM for localization. The SLAM algorithm is taking in data and estimating the pose of the camera as well as a sparse 3D ...
2
Short answer, yes, if you use your IMU to fill in the gaps.
You can use additional Bayesian filtering to fill in the pose gaps as long as you fuse in your IMU data. The IMU (assuming it has reasonable covariance and frequency) will be closer to the ground truth between the gaps than the forward propogation cBEiN recommends. cBEiN gives the solution for ...
2
This method is minimizing the reprojection error of the triangulated point. How to see this: Let $P_i$ be the $3 \times 4$ projection matrices, and let $x_i \in \mathbb{R}^3$ be the (homogenized coordinates of the) observations. This method is computing the matrix
$$
A = \sum_{i=1}^n A_i^T A_i,
$$
where
$$
A_i = P_i - x_i x_i^T P_i;
$$
and then it returns ...
Only top voted, non community-wiki answers of a minimum length are eligible
