Consortium    Solutions    Middleware    Forge    MyObjectWeb 
ObjectWeb Consortium

Advanced - Powered by Google


Project Links
· Home
· More about Think
· Related projects
· thinkClipse

· Download Nuptse
· Documentations
· Labs : Think fundamentals

· ObjectWeb Forge Site
· Report a bug

· Think team


A toolset for developing component-based verifiable embedded systems

Few words

Buzz is an experimental toolset for developing component-based verifiable embedded systems. This environment uses as input a dedicated language, called Buzz, that combines two complementary component based programming paradigms: BIP and Think. Buzz can act as a pivot and most popular execution paradigms (event-driven, Thread oriented,... ) can be translated into it. BIP is a framework for model-based development including a language for the description of heterogeneous systems, as well as associated simulation and verification tools. Buzz comes with a compiler that allows both the generation of a Think architecture for the software execution on the embedded platform and the generation of a BIP model for verifications and analysis.

How to use Buzz

In order to use Buzz, you need to download the following 3 parts:

  • first, the Nuptse compiler. As the developer did not have enough time to track all changes in Nuptse's trunk, Buzz currently uses an old version of the compiler. This version has been forked around summer 2008 and includes some backport from the trunk. The branch is named "buzz-1" and can be downloaded using the subversion command line client:
    $ svn checkout svn:// nuptse-buzz
  • the second part is the kortex library customized for Buzz. This version is nearly identical to the trunk (as of december 2008). Some incompatibilty exist though. The main one being the internal handling of the AVR 256 PC register. A little work would be needed to use kortex trunk with Buzz, but there is no show-stopper. Similarly to Nuptse, the following command can be used:
    $ svn checkout svn:// kortex-buzz
  • finally, the Buzz extension should be downloaded. It includes a plugin for the Nuptse compiler. This plugin will be able to read extra information from the ADL in order to generate both a formal model in the BIP language and a modified architecture (that compiles seamlessly to C code). Again, download it using the svn command :
    $ svn checkout svn:// buzz-trunk

After downloading, you need to compile both Nuptse and Buzz. The following assumes you used the same directories as in previous examples:

  • compile Nuptse :
    $ cd nuptse-buzz/thinkadl/
    $ ant dist
  • compile Buzz:
    $ cd buzz-trunk
    $ export THINK_PATH=/path/to/nuptse-buzz/
    $ ant dist

Then, you should be all set for compiling your first example. Be sure to correctly set both THINK_PATH and KORTEX_PATH environment variables. The first one should point to the root of your Nuptse's installation (as in the previous example). The second should point to the "src/" subdirectory in your kortex installation:

If using 'bash', the following commands could be used:

$ export THINK_PATH=$HOME/svn/think-buzz/
$ export KORTEX_PATH=$HOME/svn/kortex-buzz/src

The subdirectory 'examples' contains a set of examples. Some are NOT intended to be used to generate C code for running. Such examples includes: ac-ac, ac-pc-pc, ac-pc-ac, ac-pc-pc-ac. These are only used to generate a formal BIP model. For example intended to generate C code for real target, you should try both 'atm2561' and 'msp430' subdirectories. The easiest way to compile examples is to jump into subdirectories and simply run "make". By default, make will build both the executable and the formal model.

Loading the generated executable depends on the target platform. Helper scripts are bundled in debian packages available on this website ('avr-utils' for avr).

Using the BIP model requires the BIP compiler and tools to be installed (see for more details).

Bugs, limitations and friends

Currently, only the msp430 examples can be compiled following an interface change in some internal API. The work needed for making the AVR code work again is trivial and will eventually be taken care of.

There is a branch that focuses on unix support. It should be merged with the trunk, but this will wait. This branch uses signals to simulate interruptions and has support for user mode 'threads'. You need to use the following banches :

  • the buzz-unix branch from kortex.
  • the unix branch from buzz.

You must use the buzz version of nuptse (same as above) that includes a modified version of codegen (branch buzz). This modified codegen simply skips some broken checks, potentially allowing BAD code to be produced. These errors will hopefully be catched by the C compiler... You've been warned !


If you have any question, feel free to send an email:

Copyright © 1999-2005, ObjectWeb Consortium | contact | webmaster | Last modified at 2011-06-24 04:44 AM