The main difference in our approach is that we have not designed a product that solves a specific problem. We have instead developed a framework that allows the end user to build the system he needs. Our tools make it easy, safe and fast to deploy customized solutions in the domain of data acquisition, sailing instrumentation and navigation tools.

Having such a flexible framework does result in a set of tools that can appear big and complex as they are tools that can be applied to solve a big range of different problems. On the other hand our tools can be seen as software development tools that enable the deployment of new custom solutions for quite a wide set of common problems faster, safer and with less skill requirements that standard software development. Hence once the user has learnt how to use the tools, the need to develop software and use external development systems is greatly minimized and the potential of reusing the same tools in different scenarios is big.

The most important Bravo System components are Sailsys, BravoOnDeck and Bravo3:

  • Sailsys is the software application used to perform the data acquisition, real time data processing and logging. It usually also serves as a point of data distribution for third parties solutions. It has a windows version and a version designed to be embedded on a Bravo3 platform.
  • BravoOnDeck is the Sailsys Graphical User interface application. It runs on Windows and connects to Sailsys using TCP/IP.
  • Bravo3 is an embedded hardware platform specially designed to have Sailsys running on it. Its main feature is that it has a rich set of hardware input ports in a very compact, light and low power format.

A standard implementation is to have one instance of Sailsys performing all the data acquisition, real time data processing and data logging running on a Bravo3 unit and one or more instances of BravoOnDeck connected to the sailsys application through a wired or wireless network that allows it to interact with the system and to have specialized views of the data.

Bravo System technologies has been applied to a rich set of different scenarios like instruments for sailing boats, testing instruments, weather instruments, navigation and tactical solutions among others.


Sailsys is a software application that performs the tasks of data acquisition, light real time data processing and data logging. The functionality of a Sailsys application is described in one or more setup files that are loaded during the application start up. The user describes the system he wants to implement in the setup file using Sailsys simple scripting language. In fact a Sailsys that is started with no setup file or an empty one has almost no functionality.

Sailsys' design is component based. A component is a small piece of software that is designed to solve a very specific task; an example of component would be a GPS nmea frame decoder or a math formula like the addition of two floats. As the components only solve small problems, a single component by itself does not do much. Components then interact with each other to build a specific solution. Sailsys' scripting language is used to create the all the required components, to setup the components with specific working data (as polars data, settings, etc) and to establish the relationship between components so they can collaborate between them to implement a specific solution.

The scripting language commands can be executed at any time in the system as the scripting engine is always available. This opens a new set of system interaction possibilities and diagnostics as the system's setup can be altered live either locally or remotely.

Sailsys is delivered with a rich set of components already included. Those components support the most commonly used functionality:

  • Raw hardware acquisition from: analog inputs, pulse inputs, serial inputs, CAN inputs, Serial Ethernet servers, Racing Bravo Modules, DCell Matracan devices, etc.
  • Serial decoders: Nmea, XSens mti, MicroStrain 3DM, Octans, Phins, Dfw, FastNet, etc.
  • RBSP protocol: A TCP/UDP or serial protocol that allows interaction with expedition and end user custom software applications.
  • Data base and file logging
  • An extensive Math library that includes functionality for Polars, 1D and 2D interpolation, filtering, trigonometric, vectors, etc
  • Voice support: It enables the creation of customized voice messages that can be output using RBOnDeck on a windows platform.
  • Alarm monitor system: Monitors that chosen parameter values are within established ranges and send a warning when out.
  • ExpertSystem: The system allows acting on itself to react to certain user defined specified conditions.

With the large set of existing functionality it is possible to design quite a large number of solutions by describing the system using the scripting language and the setup files. If some specific customer feature cannot be achieved using existing functionality (as interfacing with a new sensor) it can be added using Bravo Systems custom engineering service.

Usually the new feature will be developed as a new component. As the new development is isolated from the other components, its development is easy and fast. Once developed as many instances of it can be created and debugging is easy as it only affects that component. Usually the development is small, hence the components created are normally small too. As functionality can be added in a modular and isolated way the impact of new developments is small, and testing and development tends to be safer than traditional monolithic development. In addition, as components are designed to be of as generic a purpose as possible, it is easy to reuse them, and this reduces the amount of changes needed for new developments.

For example: If we add support for a Compas decoder protocol like XSens mti with the scripting language it will be possible to define how many sensors of this type are necessary, specify what port they should attach to, if it is local or remote, etc...No modification of the binary is necessary.

On top of that Sailsys has been designed to exchange information with another instance of Sailsys, either running on the same machine or on a different machine. This is achieved using the RBSP protocol that can be attached to a serial, TCP or UDP port. This adds an extra level of flexibility that leaves open the choice of the architecture of the solution to the end user. As a result of this freedom the functionality of a setup file could be split in two or more sailsys running in two or more machines for example. Why would this be useful? Well there are many scenarios where that can be desirable. Some examples:

  • The calculation/processing load on a processor is so high that you choose to have a second computer to unload the main processor.
  • The user wants a racing processor where the features are final and not changed much, and a second processor to put experimental code.
  • The user wants a decentralized installation, so uses two processors placed in different locations to which he wires the necessary sensors.

Although the user can interact with Sailsys using its built-in shell prompt, usually Sailsys runs in the background as a service and the user interacts with it remotely using a network TCP connection and BravoOnDeck.

Bravo On Deck

BravoOnDeck is a windows application. It enables the design of user interfaces (UI) that will allow the manipulation and visualization of Sailsys data.

BravoOnDeck is also a component orientated design and has has the same scripting language as Sailsys. Given that Sailsys' functionality is defined by the user it seemed appropriate to create a system that would allow the user to design his custom UI based on the architecture he built on Sailsys.

Although BravoOnDeck functionality is also described in setup files, all the functionality can be designed graphically using the integrated Designer. Following Sailsys design, BravoOnDeck comes with an extensive set of components that will allow accessing, visualizing and manipulating Sailsys data.

If a BravoOnDeck application is launched with no setup file an empty form appears. The application basically does nothing. By right clicking on that window the designer can be enabled, so that forms can be created, components dropped into the forms and properties from forms and components manipulated.

Scripting language in BravoOnDeck adds an extra functionality as many components have events that can be triggered by certain situations. These events can be use to execute scripting commands. The commands can be executed on the local BravoOnDeck scripting engine (for example to open a new form when doing click on a buttom) or in the remote Sailsys scripting engile (for example to change between GPS1 and GPS2).

BravoOnDeck and Sailsys use a special binary protocol named SRCP. The protocol allows multiple client connections to Sailsys and multiple BravoOnDeck connections to more than one Sailsys at time. Limits on connectivity are not set on BravoOnDeck or Sailsys architecture but the computer load, and network bandwidth usage will certainly impose limits on what a specific solution can manage at a time.

BravoOnDeck design is powerful as it enables the creation of many different applications or views using the same tool. For example a BravoOnDeck version can be created just for calibration. A BravoOnDeck can be designed just to visualize numbers and graphs but not able to change any calibration, as well as a version with just a prestart view or a version with all the functionality included.

The same principles that apply to Sailsys also apply to BravoOnDeck. The amount of components and the nature of the software require some skills and good knowledge of the system in order to be able to design applications with BravoOnDeck. But those skills are far less that the ones required for developing software. In addition to that, as components in BravoOnDeck are small and usually well tested, developing with BravoOnDeck is safe and quick.

If a specific customer feature is missing, it can be added using Bravo Systems custom engineering service. Since usually it is only necessary to develop a small component, the new feature can be added in a quick and cost efficient way.