Getting prepared for the new version of Cadmium

CMakeLists.txt

@@ -3,6 +3,12 @@ project(cadmium)
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/bin)
 
+if(NOT CMAKE_BUILD_TYPE)
+    set(CMAKE_BUILD_TYPE Release)
+endif()
+set(CMAKE_CXX_FLAGS_DEBUG "-g")
+set(CMAKE_CXX_FLAGS_RELEASE "-O3")
+
 add_library(cadmium INTERFACE)
 target_include_directories(cadmium INTERFACE include/ json/include)
 
@@ -16,8 +22,26 @@ foreach(exampleSrc ${Examples})
     target_link_libraries(${exampleName} cadmium)
 endforeach(exampleSrc)
 
+if(APPLE)
+    # Apple Clang does not pack OpenMP. We must install it via HomeBrew and link it manually
+    if(CMAKE_C_COMPILER_ID MATCHES "Clang\$")
+        set(OpenMP_C_FLAGS "-Xpreprocessor -fopenmp")
+        set(OpenMP_C_LIB_NAMES "omp")
+        set(OpenMP_omp_LIBRARY omp)
+    endif()
+    if(CMAKE_CXX_COMPILER_ID MATCHES "Clang\$")
+        set(OpenMP_CXX_FLAGS "-Xpreprocessor -fopenmp")
+        set(OpenMP_CXX_LIB_NAMES "omp")
+        set(OpenMP_omp_LIBRARY omp)
+    endif()
+endif()
 find_package(OpenMP)
 if(OpenMP_CXX_FOUND)
+    if (APPLE)
+        # HomeBrew leaves a symlink to the installed version of OpenMP in these directories
+        include_directories("/usr/local/opt/libomp/include")
+        link_directories("/usr/local/opt/libomp/lib")
+    endif()
     FILE(GLOB Examples RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} example/*/parallel_main_*.cpp)
     foreach(exampleSrc ${Examples})
         get_filename_component(exampleName ${exampleSrc} NAME_WE)

build.sh

@@ -1,8 +1,40 @@
+#! /bin/bash
+
+# Function to add the CADMIUM variable to the environment
+add_cadmium_env() {
+  # Check if CADMIUM is already set in .bashrc
+  if ! grep -Fxq "export CADMIUM=$(pwd)" ~/.bashrc; then
+    echo "export CADMIUM=$(pwd)" >> ~/.bashrc
+    echo "The CADMIUM variable has been set to $(pwd) in ~/.bashrc."
+  else
+    echo "The CADMIUM variable is already set in ~/.bashrc."
+  fi
+
+  # Source the updated .bashrc
+  source ~/.bashrc
+}
+
 echo Downloading all the dependencies...
-git submodule update --init --recursive
+sudo apt install build-essential make cmake git
+git pull
+git submodule update --init --recursive --progress
 mkdir build
 cd build || exit
 cmake ..
 make all
 cd ..
 echo Compilation done. All the examples are in the bin folder
+
+cd include
+# Prompt the user for confirmation
+echo "Do you want to add cadmium ($(pwd)) to the PATH? (yes/no)"
+read -r response
+
+# Check the response and take action
+if [[ "$response" =~ ^[Yy][Ee][Ss]$ || "$response" =~ ^[Yy]$ ]]; then
+  add_cadmium_env
+elif [[ "$response" =~ ^[Nn][Oo]$ || "$response" =~ ^[Nn]$ ]]; then
+  echo "Operation canceled. The $(pwd) was not added to PATH."
+else
+  echo "Invalid response. Please run the script again and respond with 'yes' or 'no'."
+fi

celldevs_examples.sh

@@ -1,11 +1,9 @@
 echo Running asymmetric Cell-DEVS example...
-cd example/celldevs_asymm_sir || exit
-../../bin/main_asymm_sir config.json
-cd ../..
-echo Simulation done. Results are available in example/celldevs_asymm_sir/log.csv
+cd example/celldevs_sir || exit
+../../bin/main_asymm_sir asymm_config.json
+echo Simulation done. Results are available in example/celldevs_sir/log_asymm_sir.csv
 
-echo Running classic Cell-DEVS example...
-cd example/celldevs_grid_sir || exit
-../../bin/main_grid_sir config.json
+echo Running grid Cell-DEVS example...
+../../bin/main_grid_sir grid_config.json
 cd ../..
-echo Simulation done. Results are available in example/celldevs_grid_sir/log.csv
+echo Simulation done. Results are available in example/celldevs_sir/log_grid_sir.csv

example/_blinky/_main_blinky.cpp

@@ -0,0 +1,21 @@
+#include <cadmium/core/logger/csv.hpp>
+#include <cadmium/core/simulation/root_coordinator.hpp>
+#include <limits>
+#include "blinkySystem.hpp"
+
+using namespace cadmium::example::blinkySystem;
+
+int main(int argc, char *argv[]) {
+	// First, we parse the arguments
+	std::ifstream file;
+
+
+	auto model = std::make_shared<blinkySystem>("blinkySystem");
+	auto rootCoordinator = cadmium::RootCoordinator(model);
+	auto logger = std::make_shared<cadmium::CSVLogger>("log_blinkySystem.csv", ",");
+	rootCoordinator.setLogger(logger);
+	rootCoordinator.start();
+	rootCoordinator.simulate(std::numeric_limits<double>::infinity());
+	rootCoordinator.stop();
+	return 0;
+}

example/_rtModel/_main_rt_model.cpp

@@ -0,0 +1,21 @@
+#include <cadmium/core/logger/csv.hpp>
+#include <cadmium/core/simulation/root_coordinator.hpp>
+#include <limits>
+#include "covidSupervisorySystem.hpp"
+
+using namespace cadmium::example::covidSupervisorySystem;
+
+int main(int argc, char *argv[]) {
+	// First, we parse the arguments
+	std::ifstream file;
+
+
+	auto model = std::make_shared<covidSupervisorySystem>("covidSupervisorySystem");
+	auto rootCoordinator = cadmium::RootCoordinator(model);
+	auto logger = std::make_shared<cadmium::CSVLogger>("log_covidSupervisorySystem.csv", ",");
+	rootCoordinator.setLogger(logger);
+	rootCoordinator.start();
+	rootCoordinator.simulate(std::numeric_limits<double>::infinity());
+	rootCoordinator.stop();
+	return 0;
+}

example/_rtModel/include/c02SensorController.hpp

@@ -0,0 +1,104 @@
+#ifndef _C02_SENSOR_HPP__
+#define _C02_SENSOR_HPP__
+
+#include <cadmium/core/modeling/atomic.hpp>
+#include <iostream>
+
+namespace cadmium::example::covidSupervisorySystem {
+	//! Class for representing the Processor DEVS model state.
+	struct C02SensorControllerState {
+		double sigma;
+		double c02;
+		//! Processor state constructor. By default, the processor is idling.
+		C02SensorControllerState(): sigma(0), c02(1.00) {}
+	};
+
+	/**
+	 * Insertion operator for ProcessorState objects. It only displays the value of sigma.
+	 * @param out output stream.
+	 * @param s state to be represented in the output stream.
+	 * @return output stream with sigma already inserted.
+	 */
+	std::ostream& operator<<(std::ostream &out, const C02SensorControllerState& state) {
+		out << "C02 Level:," << state.c02;
+		return out;
+	}
+
+	//! Atomic DEVS model of a Job processor.
+	class C02SensorController : public Atomic<C02SensorControllerState> {
+	 private:
+		const float MIN_CO2_VOLTAGE = 0.5;  //!< Time required by the Processor model to process one Job.
+	 public:
+		Port<bool> c02In;  //!< Input Port for receiving new Job objects.
+		Port<bool> c02Safe;  //!< Output Port for sending processed Job objects.
+
+		/**
+		 * Constructor function.
+		 * @param id ID of the new Processor model object.
+		 */
+		C02SensorController(const std::string& id): Atomic<C02SensorControllerState>(id, C02SensorControllerState()) {
+			c02In = addInPort<bool>("c02In");
+			c02Safe = addOutPort<bool>("c02Safe");
+		}
+
+		/**
+		 * It updates the ProcessorState::clock, clears the ProcessorState::Job being processed, and passivates.
+		 * @param state reference to the current state of the model.
+		 */
+		void internalTransition(C02SensorControllerState& state) const override {
+			state.sigma = std::numeric_limits<double>::infinity();
+		}
+
+		/**
+		 * Updates ProcessorState::clock and ProcessorState::sigma.
+		 * If it is idling and gets a new Job via the Processor::inGenerated port, it starts processing it.
+		 * @param state reference to the current model state.
+		 * @param e time elapsed since the last state transition function was triggered.
+		 * @param x reference to the model input port set.
+		 */
+		void externalTransition(C02SensorControllerState& state, double e) const override {
+
+			if(!c02In->empty()){
+				state.sigma = 0;
+				if(c02In->getBag().back()){
+					state.c02 = 1;
+				}else{
+					state.c02 = 0; 
+				}
+
+				return;
+			}
+
+			state.sigma = std::numeric_limits<double>::infinity();
+
+
+		}
+
+		/**
+		 * It outputs the already processed ProcessorState::Job via the Processor::outProcessed port.
+		 * @param state reference to the current model state.
+		 * @param y reference to the atomic model output port set.
+		 */
+		void output(const C02SensorControllerState& state) const override {
+
+			bool safe = false;
+
+        	if(state.c02 > MIN_CO2_VOLTAGE){
+           	 	safe = true;
+        	}
+			c02Safe->addMessage(safe);
+
+		}
+
+		/**
+		 * It returns the value of ProcessorState::sigma.
+		 * @param state reference to the current model state.
+		 * @return the sigma value.
+		 */
+		[[nodiscard]] double timeAdvance(const C02SensorControllerState& state) const override {
+			return state.sigma;
+		}
+	};
+}  //namespace cadmium::example::covidSupervisorySystem
+
+#endif //_C02_SENSOR_HPP__

example/_rtModel/include/covidSupervisorySystem.hpp

@@ -0,0 +1,43 @@
+#ifndef CADMIUM_EXAMPLE_COVID_SUPERVISORY_SYSTEM_HPP_
+#define CADMIUM_EXAMPLE_COVID_SUPERVISORY_SYSTEM_HPP_
+
+#include <cadmium/core/modeling/coupled.hpp>
+#include <cadmium/lib/iestream.hpp>
+#include "./digitalInput.hpp"
+#include "./c02SensorController.hpp"
+#include "./ledController.hpp"
+#include "./occupencyController.hpp"
+
+namespace cadmium::example::covidSupervisorySystem {
+	//! Coupled DEVS model to show how the IEStream atomic model works.
+	struct covidSupervisorySystem : public Coupled {
+
+		/**
+		 * Constructor function for the iestream model.
+		 * @param id ID of the iestream model.
+		 * @param filePath path to the input file to be read.
+		 */
+		covidSupervisorySystem(const std::string& id) : Coupled(id) {
+
+			auto digitalInput = addComponent<DigitalInput>("digitalInput");
+			auto iestreamOccIn = addComponent<IEStream<bool>>("iestreamOccIn", "../example/rtModel/occIn.txt");
+			auto iestreamOccOut = addComponent<IEStream<bool>>("iestreamOccOut", "../example/rtModel/occOut.txt");
+
+
+			auto occupencyController = addComponent<OccupencyController>("occupencyController");
+			auto ledController = addComponent<LEDController>("ledController");
+			auto c02SensorController = addComponent<C02SensorController>("c02SensorController");
+
+			addCoupling(digitalInput->out, c02SensorController->c02In);
+			addCoupling(iestreamOccIn->out, occupencyController->personIn);
+			addCoupling(iestreamOccOut->out, occupencyController->personOut);
+
+
+			addCoupling(occupencyController->personSafe, ledController->occupancyIn);
+			addCoupling(c02SensorController->c02Safe, ledController->c02In);
+
+		}
+	};
+}  //namespace cadmium::example::covidSupervisorySystem
+
+#endif //CADMIUM_EXAMPLE_COVID_SUPERVISORY_SYSTEM_HPP_

example/_rtModel/include/digitPin.hpp

@@ -0,0 +1,72 @@
+/**
+* Jon Menard
+* ARSLab - Carleton University
+*
+* Digital Input:
+* Model to interface with a digital Input pin for Embedded Cadmium.
+*/
+
+
+
+#ifndef RT_DIGITALPIN_HPP
+#define RT_DIGITALPIN_HPP
+
+
+
+#include <iostream>
+#include <optional>
+
+#include <thread>
+#include <mutex>
+#include <chrono>
+#include <windows.h>
+#include <stdio.h>
+#include <string.h>
+
+
+using namespace std;
+namespace cadmium {
+
+  class DigitalPin {
+    mutable std::mutex input_mutex;
+    mutable bool keyPressed;
+
+    public:
+    DigitalPin(){
+      std::unique_lock<std::mutex> mutex_lock(input_mutex, std::defer_lock);
+      mutex_lock.lock();
+      keyPressed = false;
+      // _keyCode = keyCode;
+      mutex_lock.unlock();
+      std::thread(&DigitalPin::listen, this).detach();
+    };
+
+    bool checkPin(){
+      bool pin;
+      std::unique_lock<std::mutex> mutex_lock(input_mutex, std::defer_lock);
+      mutex_lock.lock();
+      pin = keyPressed;
+      keyPressed = false;
+
+      mutex_lock.unlock();
+
+      return pin;
+    }
+
+    void listen(){
+      std::unique_lock<std::mutex> mutex_lock(input_mutex, std::defer_lock);
+      string str;
+      while(1){
+        getline(cin, str);
+        if(str == ""){
+          mutex_lock.lock();
+          keyPressed = true;
+          mutex_lock.unlock();
+        }
+      }
+    }
+
+  };
+} // namespace cadmium
+
+#endif // RT_DIGITALPIN_HPP