mbd

C++ Model Based Development/Engineering Library

• fast: Design with 7 models executed 10.000.000 ticks in 1.55 sec on Ubuntu.
• easy to use: must implement only 2 methods: update() and is_source() in which you call add_input/add_output and get_input/set_output.
• portable: Tested on Windows 10(Visual Studio 2019), Debian VM(GCC 8.3) and Raspbian(GCC 4.9).
• syncronous and asyncronous execution(based on execution order) available with the controller.

Clone and build

Clone and build:

	git clone https://github.com/mehecip/mbd.git
	cd mbd
	cmake -DBUILD_CONTROLLER=On -DBUILD_EXAMPLES=On .
	make f=Makefile

Usage - mbd::model

Implement:

	#include "model.hpp"

	class gain : public model
	{
	public:

		/** Build your model: add inputs, outputs and parameters. */
		gain(const std::string& name, double gain) : model(name)
		{
			model::add_input<double>("In 0", 0.0);
			model::add_output<double>("Out 0", 0.0);

			model::add_param<double>("gain_factor", gain);
		}

		/** Update your model: read inputs/parameters and set outputs/parameters. */
		void update(std::uint64_t tick) override
		{
			const double in = model::get_input<double>(0);
			const double gain = model::get_param<double>("gain_factor");
			
			model::set_output<double>(0, in * gain);
		}

		/** Let the controller know if the model behaves as a source. */
		bool is_source() const override
		{
			return false;
		}
	};
	

Register:

	mbd::lib my_lib("My Lib");
	my_lib.register_model<gain>("Times Pi", 3.1415);

Build - Connect - Run without controller

Build:

	auto gain_ = my_lib.build_model("Times Pi");
	auto src_ = my_lib.build_model("Liniar Source");
	auto sink_ = my_lib.build_model("Sink");

Connect:

	mbd::end_point src_0{src_, 0, port_dir_t::OUT};
	mbd::end_point gain_0{gain_, 0, port_dir_t::IN};

	auto [state, src_to_gain] = connection::build(src_0, gain_0);

	/**************************************************************
		| Liniar Source |0>-------->0| Gain |0>-------->0| Sink | 
	***************************************************************/

Execute (in the correct order):

	for (std::uint64_t i = 0; i < 10; ++i)
	{
		src_->update(i);
		gain_->update(i);
		sink_->update(i);
	}

Usage - mbd::controller

Create the controller:

	#include "controller.hpp"
	
	void message_callback(log_level lvl, const std::string& msg)
	{
		std::cout << level_info(lvl) << ": " << msg << "\n";
	}
	
	mbd::controller cntrl(message_callback);

Add the models:

	cntrl.add_library(my_lib);

	cntrl.add_model("My Lib", "Times Pi");
	cntrl.add_model("My Lib", "Liniar Source");
	cntrl.add_model("My Lib", "Sink");

Connect the models:

	cntrl.connect("Liniar Source", 0, "Times Pi", 0);
	cntrl.connect("Times Pi", 0, "Sink", 0);

	/**************************************************************
		| Liniar Source |0>-------->0| Gain |0>-------->0| Sink | 
	***************************************************************/

Find algebraic loops:

	std::size_t n_loops = cntrl.find_algebraic_loops();

Calculate execution order and run all models:

	// syncronous
	cntrl.run(10'000);
	
	// or asyncronous
	cntrl.run_async(10'000);

Get:

	auto sink_ = cntrl.get<sink>("Sink");
	double value = sink_->read();

ToDO:

Implement mbd::view