I see. There is nothing much I am aware of but there is something. Take a look
at
https://www.youtube.com/watch?v=fj_d9NUiL-o and
http://arduino.cc, in
particular
http://arduino.cc/en/Reference/Libraries for the C++ libraries they
provide. This might get you in contact with the people who also thinks C++ might
be useful at machine control/industrial automation/robotics.
Two words of caution though:
1. It is not accidental that the most of machine control applications are
written in languages you call "crazy" (you mentioned JavaScript but there are
lots of others, in particular at some point in the past Forth was very popular,
LISP was used a lot, too. IMHO the common feature of these languages is the
virtual machine capable of compiling and executing code in target environment.
The ability to create such an environment cheaply (a typical full-fledged Forth
target-side environment was well under 10KB of code and LISP environments were
not much fatter) was apparently a critical requirement. Obviously nowadays more
more computational resources are available on the embedded side but functionally
this requirement is still there. Especially robotics and AI applications can win
tremendously from the code's being generated or sent to the environment, and
then being compiled and optimized "on the fly". Unfortunately, C++ might be the
least suitable language for even simply dynamic loading of compiled code to the
working application, let alone on-target compilation.
2. From my experience, early introduction of framework is a very common design
mistake. A good framework can IMHO only be developed by summarizing real
experience from multiple applications. Essentially, only after writing many
"essentially same" pieces of code *and putting them to production, after all
fixes that often change lots of models* you will find reasonable abstractions to
reuse. Still any new occasion might require lots of re-doing (in the
abstractions). An attempt to use a freshly-baked framework for a seemingly
pliant task is often a waste. Useful abstractions get crystallized gradually. In
some way a framework can be naturally seen as a set of constraints and rules and
hopefully we can agree that it is harmful to start constraining designs early
before building enough use cases (in our case, applications) that prove that the
rules/constraints would be indeed reasonable. It is like coming to a foreign
country and starting writing laws for its inhabitants without living among them
for a long time.
Long story short, my advice would be to develop your 1st, 2nd and maybe 3rd
*non-trivial* (this is important) application right on top of the API provided
by your platform of choice, then study the resulting code for similarities. If
the results are not crying for the framework, postpone the framework and get
back to it after developing / studying few more non-trivial applications.
-Pavel