Differential steering challenge problem

I posed a challenge problem in today's guest lecture in the Embedded Systems Programming course.  The challenge is to efficiently control a simple differential steering robot.  The Acumen code below presents both the model of the robot (dsbot), a target object, and a very simple controller.  How well the controller performs is measured in the Main object by the total energy (e) at the end of the simulation.  My score was 161.3.  You are welcome to submit to me the code of an controller that performs better.


The only rule is that you can only send me the code for the controller.  In other words, the code for the robot, target, and the main program has to remain the same.


class dsbot () // Differential steering robot
  private x=0; x'=0; y=0; y'=0;
          a=0; a'=0 ; v=0
  end
  x' [=] v * cos(a);
  y' [=] v * sin(a);
end


class target () // A simple target moving in a circle
  private t=0; t'=0; x=0; y=0 end
  t' [=] 1;
  x = 2*sin(t/1.5);
  y = 2*cos(t/1.5);
end


class controller () // A simple controller
  private t =0; t'=0; // local time
  ex = 0; ey = 0; // Error in x and y
  ia = 0; // Input angle
  ov = 0; oap = 0; // Ouput v and a'
  end
  t' [=] 1;
  if t>0.1
  t = 0;
  // Control code goes here
  if (ex*ex + ey*ey) < 1 // Robot is close enough. Slow down 
    ov = 1   
  else
    ov = 4; 
    if   (   (ex>0 && cos(ia)<0) 
          || (ey>0 && sin(ia)<0)) 
       || (  (ex<0 && cos(ia)>0) 
           ||(ey<0 && sin(ia)>0))
      oap = -10
    else
      oap = 0
    end
  end
 else
 end
end


class Main(simulator)
  private r = create dsbot ();
          t = create target ();
          c = create controller ();
          d = 0; e = 0; e'= 0; // Measures of success
  end
  // Controller see robot
    c.ex [=] t.x - r.x;
    c.ey [=] t.y - r.y;
    c.ia [=] r.a;
  // Robot listens to controller
    r.a' [=] c.oap;
    r.v [=] c.ov;
  // Error over time
    d [=] sqrt(c.ex*c.ex+c.ey*c.ey);
    e' [=] r.v*r.v + 2*d*d
end

Bouncing ball example in your favorite language

This is a request for audience participation!

The code below is a minimalist model defining the behavior of a ball subject to gravity, air resistance, and idealized bouncing.  I'd like to use this example to collect in one place code written in different hybrid modeling languages.  It would be great if you can send me (or add as comment) equivalent code written in your favorite hybrid modeling language, or for that matter any hybrid modeling language that you are familiar with.  As much as possible, please follow the same style and avoid making stylistic changes to the extent possible.  Please free to provide multiple versions if necessary, and to offer explanation of your stylistic choices as needed.

If you happen to know Verilog-AMS, PSPICE, Modelica, Sol, MapleSim, or Impromptu, I would really appreciate if you can express this model in those languages as well.  All other languages are very welcome as well!

Here's the code:


// Minimalist model for ball with airodynamic
//  resistance (2010/10/26, Scottsdale)


class Main (simulator)
 private
  a = create BouncingBall()
 end
end


class BouncingBall ()
 private
  g = -9.8; cr = 0.95; cd = 0.075;
  x = 10; x' = 2; x'' = 0;
 end


 if x>=0
  if x'<0
   x'' [=] g + cd * (x')^2
  else 
   x'' [=] g - cd * (x')^2
  end
 else
  x' = - cr * x';
  x  = 0
 end
end


Updates:


From Andre Platzer:


Here's the bouncing ball as a hybrid program:

(if (x=0) then v := -r*v fi;
 ({x'=v,v'=g+d*v^2,v<=0,x>=0}
++{x'=v,v'=g-d*v^2,v>=0,x>=0}))*

Here's the bouncing ball as a differential-algebraic program:

(if (x=0) then v := -r*v fi;
 {x'=v,((v'=g+d*v^2&v<=0)
       |(v'=g-d*v^2&v>=0)), x>=0})*

Globally Parallel, Locally Sequential. Or, “Preserving Natural Parallelism”

We have just finished a draft of a short paper describing some preliminary results on the automatically parallelizing version of Acumen.  The paper itself can be found here:

Please stay tuned for a release of the parallelizing version of Acumen that was used in these experiments!

Sneak preview of Acumen 10

Acumen 10 features improvements to the syntax, semantics, expressivity, and user interface.  The picture below is a snapshot using an example illustrating two different models of a bouncing ball.

Here's the code example in plain text:


class BouncingSpringBall1 (x,x',x'')
  x'' [=] - 9.8 + (1/x^2)
end


class BouncingSpringBall2 (x,x',x'')
  x'' [=] - 9.8;
  if (x < 0) 
    x = -x; x' = -x'
  else
  end
end


class Main (mode, simulation)
  private state = "Init" end
  switch state
   case "Init"
     create BouncingSpringBall1 (2, 0, 0);
     create BouncingSpringBall2 (2, 0, 0);
     state = "Persist"
   case "Persist"
  end
end

New features in Acumen 10 include class declarations, dynamic object creation & deletion and an explicit imperative programming language for describing what happens during discrete mode changes.

Acumen 3D Trailer

Breaking news!

A preview of what Acumen 3D will look like can be seen in the videos put together by Paul Brauner and is available on YouTube.

What New Acumen Animations Should Look Like :)

A google search for bouncing balls returned this interesting visualization of an audio, which has some nice ideas that we will try to use (at least for basic demos).

Scratch also has a bouncing ball demo.

And there is a video from some town with a bouncing ball invasion, probably somewhere in California.  :)

Draft paper

We've just finished a draft of a new paper describing the source language of Acumen and how it is compiled.  The PDF can be downloaded from the links on the right of the page.  Here's the abstract:

"Cyber-physical systems comprise digital components that directly interact with a physical environment.  Specifying the behavior desired of such systems requires analytical modeling of physical phenomena.  Similarly, testing them requires simulation of continuous systems.  While numerous tools support later stages of developing simulation codes, there is still a large gap between analytical modeling and building running simulators.  This gap significantly impedes the ability of scientists and engineers to develop novel cyber-physical systems.

We propose bridging this gap by automating the mapping from analytical models to simulation codes.  Focusing on mechanical systems as an important class of models of physical systems, we study the form of analytical models that arise in this domain, along with the process by which domain experts map them to executable codes.  We show that the key steps needed to automate this mapping are 1) a light-weight analysis to partially direct equations, 2) a binding-time analysis, and 3) an efficient implementation of symbolic differentiation.  As such, our work pinpoints and highlights a number of limitations in the state of the art in tool support of simulation, and shows how some of
these limitations can be overcome."

Enjoy!