Bringing objects to my Processing simulation

Two years ago I’ve written a post on building an object-oriented multibody structure in Matlab. The project has since been sleeping, but since my experiments with Processing I decided to implement a comparable structure there. This means:

  • A structure that is hopefully easy to expand and modify
  • Code that is running in Java (with the possibility to port it to C++ / Arduino) that should be reasonably fast.
  • A slightly modified approach compared to my original Matlab implementation (in some cases with clear improvements)

This approach allows a very elegant interface for simulation: Adding an object is just one line of code, as is simulating one timestep:

screenshot_MBSim_Processing.png

Continue reading

Advertisements

Interactive multibody dynamics in Processing

Processing is a programming language / IDE built on top of Java that’s intended for simple and visual programming, making it a great tool for WYSIWYS (what you see is what you simulate, actually that is not a real term, I just made it up).

If you’re unsure what Processing is, you might want to check out either the examples on processing.org or the double-pendulum I’ve just built into it. It is a port of my code for Arduino with TFT, but with Processing, it’s cleaner and way nicer to play with!

screenshot_double_pendulum.png

You can find an interactive version of my program here on openprocessing.org. It also includes a general implementation of the Runge-Kutta algorithm for solving ODEs, in case this is needed (without giving any guarantee of correctness or code quality – use on your own risk).

Update 2018-02-11: I’ve just published an updated version that simulates three pendulums in parallel with different algorithms (explicit euler, symplectic euler and runge-kutta). You can find it here.

6 easy tips for creating better result plots and graphics

I’m not only a simulation nerd, I’m also a visualization nerd. My interest in formatting, layout and displays has proven to be extremely helpful in my daily work, where finding the right visual is often key to analyzing and communicating large measurement and simulation datasets. Sometimes, I also find the time to participate in fun events like the recent storytelling with data visualization challenge – which also is a good excuse to write this post on plots and visualization techniques.

So here are some simple tips to get better result plots and graphs. Most of my advice is focused on visuals for simulation results, especially in the context of large datasets and use-cases where you have to plot results frequently (like multibody simulations). This often boils down to getting the workflow right – the most beautiful visuals won’t help when creating them takes more time than what’s available.

Continue reading

An Arduino Due-based Oscilloscope and Datalogger

I’ve finally built my Due and TFT into a nice housing and coded a reasonably well-working oscilloscope and datalogger for it. Here’s what I’ve learned along the way!

SDC19728.JPG

The oscilloscope showing analog input and digital output from an Arduino Uno powering a servo motor with the “knob” example sketch from the Arduino servo library.

Continue reading

Datalogging on Arduino (and compatibles): A comprehensive guide

I’ve used a lot of different configurations of Arduino-related gear as datalogging utilities. So here’s a comprehensive guide on what’s possible, how to set up stuff and on what you can expect regarding accuracy, battery life and logging speed.

(However, please keep in mind that I’m neither particularly skilled with electronics nor programming and other’s know a lot more on this than I do. I’m particularly grateful that Ed Mallon provided a link to this paper he coauthored with Patricia Beddows in the comments – the work and knowledge they put into it is just amazing)

arduino_logger_setup.JPG

My Arduino Uno with the datalogger shield both temperature and brightness sensors connected. I used a normal smartphone charger to power it for more than 3 days and placed it in this fireproof baking tray since I felt somewhat unsure about having it running unattended.

Continue reading

A Kalman filter can do interesting things (like filtering poll results)

I recently learned about the Kalman filter and finally got to play around with it a little bit. Since I had a hard time figuring out how to get it to work, here’s a practical (but yet general) introduction with examples:

A Kalman filter works by matching a simulation model and measured data. For each data point, an estimation of the simulation model’s internal state is computed based on the estimate of the previous state. This works with noisy data and limited measurement signals (e.g. a model with 10 state variables but only 2 measurement signals, although there are obvious limitations here (the more and the better the sensor data, the better the results should be – there’s also some limit on observability).

So we have this interesting tool which does all these different things:

  • filtering noisy data, while taking knowledge (or assumptions) on the underlying dynamics into account
  • merge data from several different sensors into one signal (typical application: combine GPS and acceleration sensor data into one accurate position signal)
  • offer a prediction of a system’s future state
  • estimate internal parameters of a system (say a spring stiffness based on measured oscillations)

Another interesting use is that we might try two different simulation models on the same measurement and check which one does a better job at synchronizing to the measurement (I’ll do this in a very simple example below).

Continue reading

Real-time simulations on an Arduino (double pendulum)

I got a small display compatible with my Due for christmas. And since I really wanted to see some arduino-in-the-loop simulations, I decided to use it for exactly this: real-time multibody simulations on the Ardunio and the results displayed on the tft.

Continue reading

Speed comparisons for Arduino Uno/Nano, Due and Teensy 3.5

It’s been more than a year since I published my post on numerical integration on an Arduino. Since then, the post has been quite popular, recieving a steady stream of visitors (mostly via Google). When I originally wrote it, I only had an Arduino Uno at hand – since then I’ve added a couple of Nanos and lately an Arduino Due to my inventory and decided it would be interesting to do a couple of speed tests to see how they perform. The latest addition to my growing circus of microcontroller boards is a Teensy 3.5 board.

As I pointed out in the original post, numerical integration relies heavily on floating-point math – which is something the Arduino’s 8-bit processor is not particularly good at. The Due features a 32-bit processor, a clock frequency of 84 instead of 16 MHz and the possibility to use double (64 bit) instead of float (32 bit) as a data type – so I was curious to see how it would compare to the Arduino Uno. The Nano is supposed to have more or less the same characteristics as an Uno, but is a lot smaller and cheaper – see below for details.

Now added to the comparison, the Teensy 3.5 includes a 32-bit processor with 120 MHz clock speed and a FPU for speedier floating-point math.

Continue reading

Raspberry pi: Video and Audio recording and streaming guide

I’ve spent some time on setting up audio and video streaming on my raspberry pi (mostly used as a baby monitor right now). While there are great ressources out there, it took me a lot of effort to find them and put everything together. So here’s a handy list of instructions if you want to:

  • Record and stream audio
  • Record and stream both audio and video into one file
  • Are just looking for an introduction into the topic.

Continue reading

DIY glowing lamp with shifting colors (Arduino-based and interactive)

This post is not really about multibody dynamics. Instead of simulating stuff, I’ve actually built something: A glowing, more-or-less-interactive lamp.

We are awaiting our first child and with all the things we bought (mostly used), there was a small, adorable lamp. Unfortunately, it had some weird-looking electrics inside (both looking very old and labeled for 120V – so it wouldn’t work with our 230V here in Germany), so we decided to remove all cables and replace them with LEDs. Actually, WE just decided not to use the existing cables and then I talked my wife into letting me build something with an Arduino.

So I hooked up the lamp with a digital LED-stripe – I found one that came with digitally-adressable LEDs and used the Adafruit Neopixel library to adress those. Now there are 24 RGB-LEDs inside the lamp which I can control direct with the Arduino.

Continue reading

Object-oriented multibody simulation models in Matlab

What’s better suited for object-oriented programming (OOP) than building a simulation of a physical system? Each physical object (e.g. mass, spring etc.) can be implemented as an object and then we should be able to easily build and modify large models.

However, there are a lot of challenges to get there, including:

  • How to work with classes and objects at all (if you’re like me new to OOP)?
  • How to build a working object structure that adopts to the requirements of a typical ODE solver (which usually requires access to all state variables in the so-called state-space representation)
  • How to design classes for different object types in a way that allows them interact with each other to calculate and transmit forces and accelerations.

Getting there turned out to be quite interesting and I finally got a simple object-oriented multibody model to simulate in Matlab and GNU Octave. This post is a wrapup of all the stuff I learned to get there.

Update: There is now also a newer post I’ve just written on a comparable multibody simulation structure in Processing / Java.

Continue reading

Impulse-based dynamics: A simple and fast way to simulate contacts and constraints

So far, I’ve mostly been working on rotational mechanics – multibody models where each mass only has one rotational degree of freedom and two state variables (angle and angular velocity). Every now and then, I use some commercially available tools to simulate more complex 2d and 3d models – often being surprised by how slow simulation is. At the same time, I’ve been wondering a lot:

  • how I’d actually model these problems by hand – especially when additional boundary conditions and/or contacts are involved.
  • why some video games seem to be able to include complex dynamics with detailed contact and collisions involved, simulating in real time (while commercial multibody simulation often takes hours to calculate a few seconds of dynamic behavior).

An important answer to these questions is the topic of impulse-based dynamics. I stumbled upon it in some amazing literature from Prof. Jan Bender (see http://www.interactive-graphics.de/) and so far I’ve been experimenting a bit with the method myself. This post today features a small and practical introduction to modelling boundary conditions in impulse-based mechanics.

Continue reading

How to solve differential equations on an arduino with the runge-kutta method

This is just a small update on my experiments with the Arduino. I implemented the runge-kutta-method for solving a multibody system a few weeks ago. So this is a working implementation of the standard 4th-order runge-kutta ODE (ordinary differential equations) solver for the arduino platform, something I haven’t seen elsewhere.

(Note: If you are just looking for the arduino sketch, you’ll find a link at the end of this blog post. If you are wondering about related questions or have trouble adopting it to your needs, please leave a comment. Also see this post on how numerical integration of differential equations works.
Update in August 2016: See also my new post on achievable simulation rates with an Arduino Uno/Nano and Due)

My main goal was to get a better grip on simulation speeds. Why is my simulation so slow? is a question I’m really thinking about a lot. Since I wasn’t able to find a good example of an arduino sketch for ODE solving online, this may be interesting anyway.

Continue reading

Programming advice for an engineer: Get an Arduino

Until the beginning of this year, I’ve only been coding in Matlab, GNU Octave and a few other comparable high-level 4th generation programming languages. I’ve long wanted to learn a more basic programming language which allows smaller and faster programs (more on this in another post). Basically, I wanted an answer to the question:

I’m an engineer and want to learn about programming. What can I do to get started?

It turns out one of the best answers is this: Get an Arduino.

Continue reading

Viewing friction in dynamics as a hybrid system

It’s been almost a year since I wrote my post on how to model friction in a dynamic multibody system. Since then, I’ve reconsidered my ideas from the post a few times and finally found out that there’s a theory called “hybrid systems” that intersects with the problems described there.

Continue reading

Getting started

This is an experiment that has been bugging me for quite a while.

Every now and then I run into some applied mechanics problem and try to figure out how to solve it. Usually after a few minutes of trying, I also decide to google it and often I find no solution to my question (but usually a lot of helpful hints and good advice).

These are usually quite basic questions I’m considering, like:

  • how can I implement coulomb friction in a 1d mechanics model with consideration of stick and slip states?
  • my multibody model is getting quite complex with lots of reused code. The code would probably look a lot cleaner and simpler if masses and couplings are implemented as objects. How can this be done?

Both example questions are actually quite simple problems which are probably solved many times. Searching for a good solution is fun for me and I usually learn a lot along the way. So this is the idea of this blog: to write about simple problems with multibody dynamics and suggest possible solutions to them – and then see what happens.

Continue reading