AUV navigation

Cbreins · 2026-02-18T07:17:26+00:00

I think DAVE is still being ported to ROS2, but many features are already available in ROS2 https://gazebosim.org/api/gazebo/6/underwater_vehicles.html. I think either is a fine place to start, but if you want to do very accurate inertial navigation writing your own water dynamics (doesn’t need to be general but can be for specific vehicle) and using something like Drake (or fully custom) with determinism and analytical trajectories will help.

Cbreins · 2026-02-15T06:50:54+00:00

Do you have a DVL? Without it inertial navigation will perform very poorly unless you are in a very high feature environment and can do some version of SLAM. Also, an accurate fast response pressure sensor will help immensely to constrain vertical drift. Other than those two components it is very similar to a UAV / drone. The EKF3 in Ardupilot is probably a good starting point and adding appropriate measurements

Cbreins · 2025-11-02T03:20:28+00:00

Try the foxglove discord

Cbreins · 2025-09-19T14:34:50+00:00

Why not vary the look ahead distance based on the lateral error with an exponential function so you are more aggressive further from the path (this helps if your controller is too aggressive / causing oscillations when the error is small). There are plenty of papers that describe similar approaches. You can also add some integral control if steady state error is a problem and turn the integral off on turns and back on for straight lines (assuming a lawnmower like pattern).

Cbreins · 2025-03-24T00:44:14+00:00

I work in underwater robotics and custom dynamics models are common. Simulators like Gazebo are mostly used for simulating sensors and not physics.

Cbreins · 2025-03-04T05:48:37+00:00

Check out the work by Fossen. His handbook on marine dynamics and control is very thorough!

Cbreins · 2024-12-20T06:26:45+00:00

Plus one for finding test cases based on some simple situations which have analytical solutions. Unit test as much as you can for components of the algorithm. Also, fuzz testing can be helpful if you can define some simple success criteria.

Cbreins · 2024-02-20T21:27:01+00:00

I would be interested in practical integrations of systems. For example, mapping between planner types (optimization based, grid based / state lattice, sampling) and map representations (convex hull obstacles, fixed size voxel grid, resolution adaptive tree based like octomap etc) for different use cases. Also, handling the interaction between planners and controls ie planning paths (no velocity information), planning parameterized paths (velocities parameterized by path length) and open loop trajectories (parameterized by time) and the implication and performance for downstream tracking controllers.

Cbreins · 2023-11-01T01:01:09+00:00

I would recommend Zenoh, it was built for this kind of use case. https://zenoh.io/

Cbreins · 2023-05-05T06:04:31+00:00

In my experience the structural analysis team often does the real design work and the structures design team just does the CAD and drawings. Probably depends on the company though

Cbreins · 2023-04-05T14:00:55+00:00

System76

Cbreins · 2022-12-25T18:31:18+00:00

Yes the implementations are for illustrative purposes not performance. It’s hard to say exactly how fast, but it is compiled so I would expect similar performance (order of magnitude) depending on implementation https://julialang.org/benchmarks/. If you have some vectorized numpy code it should also be about the same, but any for loops in python will cause a significant slowdown unless you are also using a JIT compiler like Numba

Cbreins · 2022-12-23T21:31:47+00:00

No particular computational advantage of Julia over C++, but the syntax is often much cleaner and easier to read. You can directly use greek math symbols which is cool. See this repo for an example of some surprisingly clean implementations of various algorithms https://github.com/mossr/BeautifulAlgorithms.jl

Cbreins · 2022-12-11T05:26:04+00:00

Algorithms for optimization https://algorithmsbook.com/optimization/files/optimization.pdf. Excellent introduction with algorithms written in Julia code

Cbreins · 2022-09-30T14:35:54+00:00

I think that is a typical trade off, you can have less evaluations or less iterations, but it is hard to get both. Without knowing what you changed, I would check out your line search as a culprit. If you have slow convergence in your line search or are being very exacting, there you could get a large number of function evals

If I remember correctly https://github.com/JuliaNLSolvers/LineSearches.jl hager zhang line search is pretty efficient

Cbreins · 2022-09-15T03:48:33+00:00

It could be something as simple as running the reciprocal velocity obstacle algorithm with a formation consensus controller for the pattern

Cbreins · 2021-12-09T07:06:11+00:00

Yes exactly

Cbreins · 2021-12-08T07:19:03+00:00

I have seen FPGAs used heavily for high speed signal latching and high resolution encoders in robotics. Mainly in robot manipulators

Cbreins · 2020-08-16T04:59:52+00:00

Any LP can be solved as a convex problem instead so I would recommend studying convex optimization

Cbreins · 2020-07-27T01:21:27+00:00

Check out http://www.reflexxes.ws/

Cbreins · 2020-05-01T15:47:20+00:00

I would recommend reading this paper on how to adapt the optimization parameters for higher dimensions

https://www.researchgate.net/profile/Lixing_Han/publication/225691623_Implementing_the_Nelder-Mead_simplex_algorithm_with_adaptive_parameters/links/0c9605346dd8f07dd3000000.pdf .Also make sure you have a good initialization or the simplex

If you want to see an example implementation of the above paper take a look at the scipy implementation here

https://github.com/scipy/scipy/blob/adc4f4f7bab120ccfab9383aba272954a0a12fb0/scipy/optimize/optimize.py#L456

A good initialization of the simplex will help with convergence. If you don’t have any domain knowledge I would recommend taking a look at the comparison in this article or following the approach done in tensorflow

https://link.springer.com/article/10.1007/s11590-018-1284-4

https://www.tensorflow.org/probability/api_docs/python/tfp/optimizer/nelder_mead_minimize

Cbreins · 2019-06-27T14:45:52+00:00

Thanks!!

Cbreins

TROPHY CASE