gv_fsm 0.3.7 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 86b23438e750da00df1eeb91db559d2176303a4a9c543fdb6acf471d5d112571
-  data.tar.gz: cb3c1ef9e8d2fe0fdf84740539425a9aa8aca3d0358de6ae2b5a69c209d4dfd7
+  metadata.gz: f58c122355c77248d9b7ef5fa2ea612c7d9c0e38057a84660155ec4a686547dd
+  data.tar.gz: dfbf56baf72ae57f70f8016d27c16770e779c093b1f8be164e50d9ac5fa914d5
 SHA512:
-  metadata.gz: 946b67acdc3dd2e435bdcda6588c2df81f4548d89003db424634b5d27e45e7a7b2698cd7583e5a51e5c1814dd5cdb5042fd719bd27d37c831dde30354935172f
-  data.tar.gz: 83b6474365979c04ea29346acc518746ee1d760eb4b144da251e2f3816956e488d68ebf4d52c7e4d234f3dfe92a14ad746f7b37d67c743078e06a68deb885177
+  metadata.gz: 0c93b183ab778b42782f2b635a7ce07e96188f798b4e8d04608f604a697b806879f8555f49858bf0a2212821ec7493a45c4ce71492466549e09d98487a58a50f
+  data.tar.gz: dd27080c97ae8da158b75fa03949e060bd21e04d11f9ca20f8d6384ae436c089eddd7153e78e31c44ab0edcf5207867819fd4babf37531e7c78bc3f93dbe7b59

data/bin/gv_fsm

@@ -16,14 +16,18 @@ op = OptionParser.new do |parser|
   EOB
 
   parser.on("-p", "--project PROJECT_NAME",
-            "Set the project name to PROJECT_NAME") do |pn|
-    sm.project_name = pn
+            "Set the project name to PROJECT_NAME (in C++ also namespace)") do |pn|
+    sm.project_name = pn.gsub(" ", "_")
   end
 
   parser.on("-d", "--description DESCRIPTION", "Use DESCRITION string in header") do |desc|
     sm.description = desc
   end
 
+  parser.on("--cpp", "Generate C++17 sources") do
+    sm.plain_c = false
+  end
+
   parser.on("-o", "--output_file NAME", "Use NAME for generated .c and .h files") do |f|
     sm.cname = f
   end
@@ -61,6 +65,11 @@ end
 
 op.parse!
 
+if sm.ino then
+  sm.plain_c = true
+  sm.syslog = false
+end
+
 unless ARGV[0]
   STDERR.puts "ERROR: I need the path to a Graphviz file!\n\n"
   STDERR.puts op
@@ -93,7 +102,7 @@ if !(top[:sources].count == 1 and top[:sinks].count <= 1) then
   exit 4
 end
 
-puts "Generating C functions for states: #{sm.states_list.join(", ")}."
+puts "Generating #{sm.plain_c ? "C" : "C++17"} functions for states: #{sm.states_list.join(", ")}."
 puts "                   for transition: #{sm.transition_functions_list.join(", ")}."
 
 if (sm.sigint) then
@@ -104,7 +113,7 @@ if (sm.sigint) then
 end
 
 if options[:header] then
-  name = sm.generate_h 
+  name = sm.generate_h
   puts "Generated header #{name}"
 end
 

data/lib/gv_fsm.rb

@@ -11,6 +11,7 @@ module GV_FSM
   class FSM
     attr_reader :states, :transitions, :dotfile, :prefix, :error
     attr_accessor :project_name, :description, :cname, :syslog, :ino, :sigint
+    attr_accessor :plain_c
     include GV_FSM::Templates
 
     def initialize(filename = nil)
@@ -21,6 +22,7 @@ module GV_FSM
       @matrix = nil
       @nodemap = {}
       @sigint = nil
+      @plain_c = true
       parse(filename) if filename
     end
 
@@ -141,20 +143,21 @@ module GV_FSM
     end
 
     def generate_c(filename = @cname)
-      ext = @ino ? "cpp" : "c"
+      ext = (@ino || !@plain_c) ? "cpp" : "c"
       fname = "#{filename}.#{ext}"
       File.open(fname, "w") do |f|
-        f.puts ERB.new(HEADER, trim_mode: "<>").result(binding)
-        f.puts ERB.new(CC, trim_mode: "<>").result(binding)
+        f.puts ERB.new(HEADER, trim_mode: "<>-").result(binding)
+        f.puts ERB.new(@plain_c ? CC : CPP, trim_mode: "<>-").result(binding)
       end
       return fname
     end
 
     def generate_h(filename = @cname)
-      fname = "#{filename}.h"
+      ext = @plain_c ? "h" : "hpp"
+      fname = "#{filename}.#{ext}"
       File.open(fname, "w") do |f|
-        f.puts ERB.new(HEADER, trim_mode: "<>").result(binding)
-        f.puts ERB.new(HH, trim_mode: "<>").result(binding)
+        f.puts ERB.new(HEADER, trim_mode: "<>-").result(binding)
+        f.puts ERB.new(@plain_c ? HH : HPP, trim_mode: "<>-").result(binding)
       end
       return fname
     end

data/lib/templates.rb

@@ -1,6 +1,13 @@
 
 module GV_FSM
   module Templates
+
+    #   _   _ _____    _    ____  _____ ____  
+    #  | | | | ____|  / \  |  _ \| ____|  _ \ 
+    #  | |_| |  _|   / _ \ | | | |  _| | |_) |
+    #  |  _  | |___ / ___ \| |_| | |___|  _ < 
+    #  |_| |_|_____/_/   \_\____/|_____|_| \_\
+                                            
     HEADER =<<~EOHEADER
       /******************************************************************************
       Finite State Machine
@@ -21,294 +28,643 @@ module GV_FSM
 
     EOHEADER
 
+    #    ____   _   _ _____    _    ____  _____ ____  
+    #   / ___| | | | | ____|  / \  |  _ \| ____|  _ \ 
+    #  | |     | |_| |  _|   / _ \ | | | |  _| | |_) |
+    #  | |___  |  _  | |___ / ___ \| |_| | |___|  _ < 
+    #   \____| |_| |_|_____/_/   \_\____/|_____|_| \_\
+                                                    
+                                                                    
+
     HH =<<~EOH
-      <% if !@ino then %>
-      #ifndef <%= File::basename(@cname).upcase %>_H
-      #define <%= File::basename(@cname).upcase %>_H
-      #ifdef __cplusplus
-      extern "C" {
-      #endif
-      #include <stdlib.h>
-      <% else %>
-      #include <arduino.h>
-      <% end %>
+<% if !@ino then %>
+#ifndef <%= File::basename(@cname).upcase %>_H
+#define <%= File::basename(@cname).upcase %>_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include <stdlib.h>
+<% else -%>
+#include <arduino.h>
+<% end -%>
 
-      // State data object
-      // By default set to void; override this typedef or load the proper
-      // header if you need
-      typedef void <%= @prefix %>state_data_t;
-      <% if !@ino then %>
-      
-      // NOTHING SHALL BE CHANGED AFTER THIS LINE!
-      <% end %>
+// State data object
+// By default set to void; override this typedef or load the proper
+// header if you need
+typedef void <%= @prefix %>state_data_t;
+<% if !@ino then -%>
 
-      // List of states
-      typedef enum {
-      <% @states.each_with_index do |s, i| %>
-        <%= @prefix.upcase %>STATE_<%= s[:id].upcase %><%= i == 0 ? " = 0" : "" %>,  
-      <% end %>
-        <%= @prefix.upcase %>NUM_STATES,
-        <%= @prefix.upcase %>NO_CHANGE
-      } <%= @prefix %>state_t;
+// NOTHING SHALL BE CHANGED AFTER THIS LINE!
+<% end -%>
 
-      // State human-readable names
-      extern const char *<%= @prefix %>state_names[];
-      
-      <% if transition_functions_list.count > 0 then %>
-      // State function and state transition prototypes
-      typedef <%= @prefix %>state_t state_func_t(<%= @prefix %>state_data_t *data);
-      typedef void transition_func_t(<%= @prefix %>state_data_t *data);
-      <% else %>
-      // State function prototype
-      typedef <%= @prefix %>state_t state_func_t(<%= @prefix %>state_data_t *data);
-      <%end %>
-
-      // State functions
-      <% dest = destinations.dup %>
-      <% @states.each do |s| %>
-      <% stable = true if dest[s[:id]].include? s[:id] %>
-      <% dest[s[:id]].map! {|n| (@prefix+"STATE_"+n).upcase} %>
-      <% if dest[s[:id]].empty? or stable then
-        dest[s[:id]].unshift @prefix.upcase+"NO_CHANGE"
-      end %>
-      // Function to be executed in state <%= s[:id] %>
-      // valid return states: <%= dest[s[:id]].join(", ") %>
-      <%= @prefix %>state_t <%= s[:function] %>(<%= @prefix %>state_data_t *data);
-      <% end %>
+// List of states
+typedef enum {
+<% @states.each_with_index do |s, i| -%>
+  <%= @prefix.upcase %>STATE_<%= s[:id].upcase %><%= i == 0 ? " = 0" : "" %>,  
+<% end -%>
+  <%= @prefix.upcase %>NUM_STATES,
+  <%= @prefix.upcase %>NO_CHANGE
+} <%= @prefix %>state_t;
 
+// State human-readable names
+extern const char *<%= @prefix %>state_names[];
 
-      // List of state functions
-      extern state_func_t *const <%= @prefix %>state_table[<%= @prefix.upcase %>NUM_STATES];
-      
+<% if transition_functions_list.count > 0 then -%>
+// State function and state transition prototypes
+typedef <%= @prefix %>state_t state_func_t(<%= @prefix %>state_data_t *data);
+typedef void transition_func_t(<%= @prefix %>state_data_t *data);
+<% else -%>
+// State function prototype
+typedef <%= @prefix %>state_t state_func_t(<%= @prefix %>state_data_t *data);
+<%end -%>
 
-      <% if transition_functions_list.count > 0 then %>
-      // Transition functions
-      <% transition_functions_list.each do |t| %>
-      <% next if t == "NULL" %>
-      void <%= t %>(<%= @prefix %>state_data_t *data);
-      <% end %>
+// State functions
+<% dest = destinations.dup -%>
+<% @states.each do |s| -%>
+<% stable = true if dest[s[:id]].include? s[:id] -%>
+<% dest[s[:id]].map! {|n| (@prefix+"STATE_"+n).upcase} -%>
+<% if dest[s[:id]].empty? or stable then
+  dest[s[:id]].unshift @prefix.upcase+"NO_CHANGE"
+end -%>
+// Function to be executed in state <%= s[:id] %>
+// valid return states: <%= dest[s[:id]].join(", ") %>
+<%= @prefix %>state_t <%= s[:function] %>(<%= @prefix %>state_data_t *data);
+<% end -%>
 
-      // Table of transition functions
-      extern transition_func_t *const <%= @prefix %>transition_table[<%= @prefix.upcase %>NUM_STATES][<%= @prefix.upcase %>NUM_STATES];
-      <% else %>
-      // No transition functions
-      <% end %>
 
-      // state manager
-      <%= @prefix %>state_t <%= @prefix %>run_state(<%= @prefix %>state_t cur_state, <%= @prefix %>state_data_t *data);
-      
-      <% if !@ino then %>
-      #ifdef __cplusplus
-      }
-      #endif
-      #endif // <%= File::basename(@cname).upcase %>_H
-      <% end %>
+// List of state functions
+extern state_func_t *const <%= @prefix %>state_table[<%= @prefix.upcase %>NUM_STATES];
+
+
+<% if transition_functions_list.count > 0 then -%>
+// Transition functions
+<% transition_functions_list.each do |t| -%>
+<% next if t == "NULL" -%>
+void <%= t %>(<%= @prefix %>state_data_t *data);
+<% end -%>
+
+// Table of transition functions
+extern transition_func_t *const <%= @prefix %>transition_table[<%= @prefix.upcase %>NUM_STATES][<%= @prefix.upcase %>NUM_STATES];
+<% else -%>
+// No transition functions
+<% end -%>
+
+// state manager
+<%= @prefix %>state_t <%= @prefix %>run_state(<%= @prefix %>state_t cur_state, <%= @prefix %>state_data_t *data);
+
+<% if !@ino then -%>
+#ifdef __cplusplus
+}
+#endif
+#endif // <%= File::basename(@cname).upcase %>_H
+<% end -%>
     EOH
 
+
+    #    ____   ____   ___  _   _ ____   ____ _____ 
+    #   / ___| / ___| / _ \| | | |  _ \ / ___| ____|
+    #  | |     \___ \| | | | | | | |_) | |   |  _|  
+    #  | |___   ___) | |_| | |_| |  _ <| |___| |___ 
+    #   \____| |____/ \___/ \___/|_| \_\\____|_____|
+                                                  
+
     CC =<<~EOC
-      <% if !@ino then %>
-      <% if @syslog then %>
-      <% log = :syslog %>
-      #include <syslog.h>
-      <% end %>
-      <% else %>
-      <% if @syslog then log = :ino end %>
-      <% end %>
-      #include "<%= File::basename(@cname) %>.h"
-      
-      <% if sigint then %>// Install signal handler: 
-      // SIGINT requests a transition to state <%= self.sigint %>
-      #include <signal.h>
-      static int _exit_request = 0;
-      static void signal_handler(int signal) {
-        if (signal == SIGINT) {
-          _exit_request = 1;<% if log == :syslog then %>
-          syslog(LOG_WARNING, "[FSM] SIGINT transition to <%= sigint %>");<% elsif log == :ino then %>
-          Serial.println("[FSM] SIGINT transition to <%= sigint %>");<% end %>
-        }
-      }
+<% if !@ino then -%>
+<% if @syslog then -%>
+<% log = :syslog %>
+#include <syslog.h>
+<% end -%>
+<% else -%>
+<% if @syslog then log = :ino end -%>
+<% end -%>
+#include "<%= File::basename(@cname) %>.h"
 
-      <% end %>
-      <% placeholder = "Your Code Here" %>
-      // SEARCH FOR <%= placeholder %> FOR CODE INSERTION POINTS!
-
-      // GLOBALS
-      // State human-readable names
-      const char *<%= @prefix %>state_names[] = {<%= states_list.map {|sn| '"'+sn+'"'}.join(", ") %>};
-
-      // List of state functions
-      <% fw = state_functions_list.max {|a, b| a.length <=> b.length}.length %>
-      state_func_t *const <%= @prefix %>state_table[<%= @prefix.upcase %>NUM_STATES] = {
-      <% @states.each do |s| %>
-        <%= (s[:function] + ',').ljust(fw+1) %> // in state <%= s[:id] %>
-      <% end %>
-      };
-      <% if transition_functions_list.count > 0 then %>
-      
-      // Table of transition functions
-      transition_func_t *const <%= @prefix %>transition_table[<%= @prefix.upcase %>NUM_STATES][<%= @prefix.upcase %>NUM_STATES] = {
-      <% sl = states_list %>
-      <% fw = transition_functions_list.max {|a, b| a.length <=> b.length}.length %>
-      <% sw = [states_list, "states:"].flatten.max {|a, b| a.length <=> b.length}.length %>
-        /* <%= "states:".ljust(sw) %>     <%= sl.map {|e| e.ljust(fw) }.join(", ") %> */
-      <% transitions_map.each_with_index do |l, i| %>
-        /* <%= sl[i].ljust(sw) %> */ {<%= l.map {|e| e.ljust(fw)}.join(", ") %>}, 
-      <% end %>
-      };
-      <% else %>
-      // No transition functions
-      <% end %>
+<% if sigint then %>// Install signal handler: 
+// SIGINT requests a transition to state <%= self.sigint %>
+#include <signal.h>
+static int _exit_request = 0;
+static void signal_handler(int signal) {
+  if (signal == SIGINT) {
+    _exit_request = 1;<% if log == :syslog then %>
+    syslog(LOG_WARNING, "[FSM] SIGINT transition to <%= sigint %>");<% elsif log == :ino then %>
+    Serial.println("[FSM] SIGINT transition to <%= sigint %>");<% end %>
+  }
+}
 
-      /*  ____  _        _       
-       * / ___|| |_ __ _| |_ ___ 
-       * \\___ \\| __/ _` | __/ _ \\
-       *  ___) | || (_| | ||  __/
-       * |____/ \\__\\__,_|\\__\\___|
-       *                         
-       *   __                  _   _                 
-       *  / _|_   _ _ __   ___| |_(_) ___  _ __  ___ 
-       * | |_| | | | '_ \\ / __| __| |/ _ \\| '_ \\/ __|
-       * |  _| |_| | | | | (__| |_| | (_) | | | \\__ \\
-       * |_|  \\__,_|_| |_|\\___|\\__|_|\\___/|_| |_|___/
-       */                                             
-      <% dest = destinations.dup %>
-      <% topo = self.topology %>
-      <% @states.each do |s| %>
-      <% stable = true if dest[s[:id]].include? s[:id] %>
-      <% dest[s[:id]].map! {|n| (@prefix+"STATE_"+n).upcase} %>
-      <% if dest[s[:id]].empty? or stable then
-        dest[s[:id]].unshift @prefix.upcase+"NO_CHANGE"
-      end %>
-      // Function to be executed in state <%= s[:id] %>
-      // valid return states: <%= dest[s[:id]].join(", ") %>
-      <% if sigint && stable && topo[:sources][0] != s[:id] then %>
-      // SIGINT triggers an emergency transition to <%= self.sigint %>
-      <% end %>
-      <%= @prefix %>state_t <%= s[:function] %>(<%= @prefix %>state_data_t *data) {
-        <%= @prefix %>state_t next_state = <%= dest[s[:id]].first %>;
-        <% if sigint && topo[:sources][0] == s[:id] then %>signal(SIGINT, signal_handler); 
-        <% end %>
-      <% if log == :syslog then %>
-        syslog(LOG_INFO, "[FSM] In state <%= s[:id] %>");
-      <% elsif log == :ino then %>
-        Serial.println("[FSM] In state <%= s[:id] %>");
-      <% end %>
-        /* <%= placeholder %> */
-        
-        switch (next_state) {
-      <% dest[s[:id]].each  do |str| %>
-          case <%= str %>:
-      <% end %>
-            break;
-          default:
-      <% if log == :syslog then %>
-            syslog(LOG_WARNING, "[FSM] Cannot pass from <%= s[:id] %> to %s, remaining in this state", <%= @prefix %>state_names[next_state]);
-      <% elsif log == :ino then %>
-            Serial.print("[FSM] Cannot pass from <%= s[:id] %> to ");
-            Serial.print(<%= @prefix %>state_names[next_state]);
-            Serial.println(", remaining in this state");
-      <% end %>
-            next_state = <%= @prefix.upcase %>NO_CHANGE;
-        }
-        <% if sigint && stable && topo[:sources][0] != s[:id] then %>
-        // SIGINT transition override
-        if (_exit_request) next_state = <%= (@prefix+"STATE_"+self.sigint ).upcase %>;
-        <% end %>
-        return next_state;
-      }
+<% end -%>
+<% placeholder = "Your Code Here" -%>
+// SEARCH FOR <%= placeholder %> FOR CODE INSERTION POINTS!
 
-      <% end %>
+// GLOBALS
+// State human-readable names
+const char *<%= @prefix %>state_names[] = {<%= states_list.map {|sn| '"'+sn+'"'}.join(", ") %>};
 
-      <% if transition_functions_list.count > 0 then %>
-      /*  _____                    _ _   _              
-       * |_   _| __ __ _ _ __  ___(_) |_(_) ___  _ __   
-       *   | || '__/ _` | '_ \\/ __| | __| |/ _ \\| '_ \\
-       *   | || | | (_| | | | \\__ \\ | |_| | (_) | | | | 
-       *   |_||_|  \\__,_|_| |_|___/_|\\__|_|\\___/|_| |_| 
-       *                                                
-       *   __                  _   _                 
-       *  / _|_   _ _ __   ___| |_(_) ___  _ __  ___ 
-       * | |_| | | | '_ \\ / __| __| |/ _ \\| '_ \\/ __|
-       * |  _| |_| | | | | (__| |_| | (_) | | | \\__ \\
-       * |_|  \\__,_|_| |_|\\___|\\__|_|\\___/|_| |_|___/
-       */    
-                                               
-      <% transition_functions_list.each do |t| %>
-      <% next if t == "NULL" %>
-      <% tpaths = transitions_paths[t] %>
-      // This function is called in <%= tpaths.count %> transition<%= tpaths.count == 1 ? '' : 's' %>:
-      <% tpaths.each_with_index do |e, i| %>
-      // <%= i+1 %>. from <%= e[:from] %> to <%= e[:to] %>
-      <% end %>
-      void <%= t %>(<%= @prefix %>state_data_t *data) {
-      <% if log == :syslog then %>
-        syslog(LOG_INFO, "[FSM] State transition <%= t %>");
-      <% elsif log == :ino then %>
-        Serial.println("[FSM] State transition <%= t %>");
-      <% end %>
-        /* <%= placeholder %> */
-      }
+// List of state functions
+<% fw = state_functions_list.max {|a, b| a.length <=> b.length}.length -%>
+state_func_t *const <%= @prefix %>state_table[<%= @prefix.upcase %>NUM_STATES] = {
+<% @states.each do |s| -%>
+  <%= (s[:function] + ',').ljust(fw+1) %> // in state <%= s[:id] %>
+<% end -%>
+};
+<% if transition_functions_list.count > 0 then -%>
 
-      <% end %>
-      <% end %>
+// Table of transition functions
+transition_func_t *const <%= @prefix %>transition_table[<%= @prefix.upcase %>NUM_STATES][<%= @prefix.upcase %>NUM_STATES] = {
+<% sl = states_list -%>
+<% fw = transition_functions_list.max {|a, b| a.length <=> b.length}.length -%>
+<% sw = [states_list, "states:"].flatten.max {|a, b| a.length <=> b.length}.length -%>
+  /* <%= "states:".ljust(sw) %>     <%= sl.map {|e| e.ljust(fw) }.join(", ") %> */
+<% transitions_map.each_with_index do |l, i| -%>
+  /* <%= sl[i].ljust(sw) %> */ {<%= l.map {|e| e.ljust(fw)}.join(", ") %>}, 
+<% end -%>
+};
+<% else -%>
+// No transition functions
+<% end -%>
+
+/*  ____  _        _       
+ * / ___|| |_ __ _| |_ ___ 
+ * \\___ \\| __/ _` | __/ _ \\
+ *  ___) | || (_| | ||  __/
+ * |____/ \\__\\__,_|\\__\\___|
+ *                         
+ *   __                  _   _                 
+ *  / _|_   _ _ __   ___| |_(_) ___  _ __  ___ 
+ * | |_| | | | '_ \\ / __| __| |/ _ \\| '_ \\/ __|
+ * |  _| |_| | | | | (__| |_| | (_) | | | \\__ \\
+ * |_|  \\__,_|_| |_|\\___|\\__|_|\\___/|_| |_|___/
+ */                                             
+<% dest = destinations.dup -%>
+<% topo = self.topology -%>
+<% @states.each do |s| -%>
+<% stable = true if dest[s[:id]].include? s[:id] -%>
+<% dest[s[:id]].map! {|n| (@prefix+"STATE_"+n).upcase} -%>
+<% if dest[s[:id]].empty? or stable then
+  dest[s[:id]].unshift @prefix.upcase+"NO_CHANGE"
+end %>
+// Function to be executed in state <%= s[:id] %>
+// valid return states: <%= dest[s[:id]].join(", ") %>
+<% if sigint && stable && topo[:sources][0] != s[:id] then -%>
+// SIGINT triggers an emergency transition to <%= self.sigint %>
+<% end -%>
+<%= @prefix %>state_t <%= s[:function] %>(<%= @prefix %>state_data_t *data) {
+  <%= @prefix %>state_t next_state = <%= dest[s[:id]].first -%>;
+<% if sigint && topo[:sources][0] == s[:id] then -%>
+  signal(SIGINT, signal_handler); 
+  <% end -%>
+<% if log == :syslog then -%>
+  syslog(LOG_INFO, "[FSM] In state <%= s[:id] %>");
+<% elsif log == :ino then -%>
+  Serial.println("[FSM] In state <%= s[:id] %>");
+<% end -%>
+  /* <%= placeholder %> */
+  
+  switch (next_state) {
+<% dest[s[:id]].each  do |str| -%>
+  case <%= str %>:
+<% end -%>
+    break;
+  default:
+<% if log == :syslog then -%>
+    syslog(LOG_WARNING, "[FSM] Cannot pass from <%= s[:id] %> to %s, remaining in this state", <%= @prefix %>state_names[next_state]);
+<% elsif log == :ino then -%>
+    Serial.print("[FSM] Cannot pass from <%= s[:id] %> to ");
+    Serial.print(<%= @prefix %>state_names[next_state]);
+    Serial.println(", remaining in this state");
+<% end -%>
+    next_state = <%= @prefix.upcase %>NO_CHANGE;
+  }
+<% if sigint && stable && topo[:sources][0] != s[:id] then -%>
+  // SIGINT transition override
+  if (_exit_request) 
+    next_state = <%= (@prefix+"STATE_"+self.sigint ).upcase %>;
+<% end %>
+  return next_state;
+}
+
+<% end %>
+
+<% if transition_functions_list.count > 0 then -%>
+/*  _____                    _ _   _              
+ * |_   _| __ __ _ _ __  ___(_) |_(_) ___  _ __   
+ *   | || '__/ _` | '_ \\/ __| | __| |/ _ \\| '_ \\
+ *   | || | | (_| | | | \\__ \\ | |_| | (_) | | | | 
+ *   |_||_|  \\__,_|_| |_|___/_|\\__|_|\\___/|_| |_| 
+ *                                                
+ *   __                  _   _                 
+ *  / _|_   _ _ __   ___| |_(_) ___  _ __  ___ 
+ * | |_| | | | '_ \\ / __| __| |/ _ \\| '_ \\/ __|
+ * |  _| |_| | | | | (__| |_| | (_) | | | \\__ \\
+ * |_|  \\__,_|_| |_|\\___|\\__|_|\\___/|_| |_|___/
+ */    
+                                          
+<% transition_functions_list.each do |t| -%>
+<% next if t == "NULL" -%>
+<% tpaths = transitions_paths[t] -%>
+// This function is called in <%= tpaths.count %> transition<%= tpaths.count == 1 ? '' : 's' %>:
+<% tpaths.each_with_index do |e, i| -%>
+// <%= i+1 %>. from <%= e[:from] %> to <%= e[:to] %>
+<% end -%>
+void <%= t %>(<%= @prefix %>state_data_t *data) {
+<% if log == :syslog then -%>
+  syslog(LOG_INFO, "[FSM] State transition <%= t %>");
+<% elsif log == :ino then -%>
+  Serial.println("[FSM] State transition <%= t %>");
+<% end -%>
+  /* <%= placeholder %> */
+}
+
+<% end -%>
+<% end -%>
+
+/*  ____  _        _        
+ * / ___|| |_ __ _| |_ ___  
+ * \\___ \\| __/ _` | __/ _ \\
+ *  ___) | || (_| | ||  __/ 
+ * |____/ \\__\\__,_|\\__\\___| 
+ *                          
+ *                                              
+ *  _ __ ___   __ _ _ __   __ _  __ _  ___ _ __ 
+ * | '_ ` _ \\ / _` | '_ \\ / _` |/ _` |/ _ \\ '__|
+ * | | | | | | (_| | | | | (_| | (_| |  __/ |   
+ * |_| |_| |_|\\__,_|_| |_|\\__,_|\\__, |\\___|_|   
+ *                              |___/           
+ */
+
+<%= @prefix %>state_t <%= @prefix %>run_state(<%= @prefix %>state_t cur_state, <%= @prefix %>state_data_t *data) {
+  <%= @prefix %>state_t new_state = <%= @prefix %>state_table[cur_state](data);
+  if (new_state == <%= @prefix.upcase %>NO_CHANGE) new_state = cur_state;
+<% if transition_functions_list.count > 0 then %>
+  transition_func_t *transition = <%= @prefix %>transition_table[cur_state][new_state];
+  if (transition)
+    transition(data);
+<% end %>
+  return new_state;
+};
+
+<% if @ino then %>
+/* Example usage:
+<%= @prefix %>state_data_t data = {count: 1};
+
+void loop() {
+  static <%= @prefix %>state_t cur_state = <%= @prefix.upcase %>STATE_INIT;
+  cur_state = <%= @prefix %>run_state(cur_state, &data);
+}
+*/
+<% else %>
+<% nsinks = topology[:sinks].count %>
+#ifdef TEST_MAIN
+#include <unistd.h>
+int main() {
+  <%= @prefix %>state_t cur_state = <%= @prefix.upcase %>STATE_<%= @states.first[:id].upcase %>;
+<% if @syslog then %>
+  openlog("SM", LOG_PID | LOG_PERROR, LOG_USER);
+  syslog(LOG_INFO, "Starting SM");
+<% end %>
+  do {
+    cur_state = <%= @prefix %>run_state(cur_state, NULL);
+    sleep(1);
+<% if nsinks == 1 %>
+  } while (cur_state != <%= @prefix.upcase %>STATE_<%= topology[:sinks][0].upcase %>);
+  <%= @prefix %>run_state(cur_state, NULL);
+<% else %>
+  } while (1);
+<% end %>
+  return 0;
+}
+#endif
+<% end %>
+    EOC
 
-      /*  ____  _        _        
-       * / ___|| |_ __ _| |_ ___  
-       * \\___ \\| __/ _` | __/ _ \\
-       *  ___) | || (_| | ||  __/ 
-       * |____/ \\__\\__,_|\\__\\___| 
-       *                          
-       *                                              
-       *  _ __ ___   __ _ _ __   __ _  __ _  ___ _ __ 
-       * | '_ ` _ \\ / _` | '_ \\ / _` |/ _` |/ _ \\ '__|
-       * | | | | | | (_| | | | | (_| | (_| |  __/ |   
-       * |_| |_| |_|\\__,_|_| |_|\\__,_|\\__, |\\___|_|   
-       *                              |___/           
-       */
-
-      <%= @prefix %>state_t <%= @prefix %>run_state(<%= @prefix %>state_t cur_state, <%= @prefix %>state_data_t *data) {
-        <%= @prefix %>state_t new_state = <%= @prefix %>state_table[cur_state](data);
-        if (new_state == <%= @prefix.upcase %>NO_CHANGE) new_state = cur_state;
-      <% if transition_functions_list.count > 0 then %>
-        transition_func_t *transition = <%= @prefix %>transition_table[cur_state][new_state];
-        if (transition)
-          transition(data);
-      <% end %>
-        return new_state;
-      };
 
-      <% if @ino then %>
-      /* Example usage:
-      <%= @prefix %>state_data_t data = {count: 1};
+    #    ____ ____  ____    _   _ _____    _    ____  _____ ____  
+    #   / ___|  _ \|  _ \  | | | | ____|  / \  |  _ \| ____|  _ \ 
+    #  | |   | |_) | |_) | | |_| |  _|   / _ \ | | | |  _| | |_) |
+    #  | |___|  __/|  __/  |  _  | |___ / ___ \| |_| | |___|  _ < 
+    #   \____|_|   |_|     |_| |_|_____/_/   \_\____/|_____|_| \_\
+                                                                
 
-      void loop() {
-        static <%= @prefix %>state_t cur_state = <%= @prefix.upcase %>STATE_INIT;
-        cur_state = <%= @prefix %>run_state(cur_state, &data);
+    HPP =<<~EOHPP
+#ifndef <%= File::basename(@cname).upcase %>_HPP
+#define <%= File::basename(@cname).upcase %>_HPP
+#include <functional>
+#include <iostream>
+#include <map>
+#include <string>
+#include <tuple>
+<% if @syslog then -%>
+<% log = :syslog -%>
+#include <syslog.h>
+<% end -%>
+<% if sigint then -%>
+// Install signal handler: 
+// SIGINT requests a transition to state <%= self.sigint %>
+#include <csignal>
+<% end %>
+
+using namespace std::string_literals;
+<% ns = @project_name || "FSM" -%>
+namespace <%= ns %> {
+static bool <%= self.sigint %>_requested = false;
+
+// List of states
+typedef enum {
+<% @states.each do |s| -%>
+  <%= @prefix.upcase %>STATE_<%= s[:id].upcase %>,
+<% end -%>
+  <%= @prefix.upcase %>NUM_STATES,
+  <%= @prefix.upcase %>NO_CHANGE,
+  <%= @prefix.upcase %>UNIMPLEMENTED
+} <%= @prefix %>state_t;
+
+// State human-readable names
+std::map<<%= @prefix %>state_t, char const *> state_names = {
+<% @states.each do |s| -%>
+  {<%= @prefix.upcase %>STATE_<%= s[:id].upcase %>, "<%= s[:id].upcase %>"},
+<% end -%>
+  {<%= @prefix.upcase %>NUM_STATES, "NUM_STATES"},
+  {<%= @prefix.upcase %>NO_CHANGE, "NO_CHANGE"},
+  {<%= @prefix.upcase %>UNIMPLEMENTED, "UNIMPLEMENTED"}
+};
+
+// Custom state functions:
+<% @states.each do |s| -%>
+template<class T> 
+<%= @prefix %>state_t <%= s[:function] %>(T &data);
+<% end -%>
+
+<% if transition_functions_list.count > 0 then -%>
+// Custom transition functions:
+<% transition_functions_list.each do |t| -%>
+template<class T>
+void <%= t %>(T &data);
+<% end -%>
+<% end -%>
+
+// Finite State Machine class
+template <typename DATA_T> 
+class FiniteStateMachine {
+
+// Function templates
+using state_fun = std::function<<%= @prefix %>state_t(DATA_T &data)>;
+using transition_fun = std::function<void(DATA_T &data)>;
+using operation_fun = std::function<void(DATA_T &data)>;
+
+private:
+  std::pair<<%= @prefix %>state_t, <%= @prefix %>state_t> _state{<%= @prefix.upcase %>STATE_<%= states[0][:id].upcase %>, <%= @prefix.upcase %>STATE_<%= states[0][:id].upcase %>};
+  std::map<<%= @prefix %>state_t, state_fun> _states;
+  std::map<<%= @prefix %>state_t, std::map<<%= @prefix %>state_t, transition_fun>> _transitions;
+  std::function<void()> _timing_func;
+  DATA_T *_data;
+
+public:
+
+  FiniteStateMachine(DATA_T *data) : _data(data) {
+    install_functions();
+  }
+  ~FiniteStateMachine(){};
+
+  void set_timing_function(std::function<void()> timing_func) {
+    _timing_func = timing_func;
+  }
+
+  void add_state(<%= @prefix %>state_t name, state_fun func) { _states[name] = func; }
+
+  void add_transition(<%= @prefix %>state_t from, <%= @prefix %>state_t to, transition_fun func) {
+    _transitions[from][to] = func;
+  }
+
+  inline <%= @prefix %>state_t state() { return _state.second; }
+  inline std::string state_name() { return std::string(state_names[_state.second]); }
+  inline <%= @prefix %>state_t prev_state() { return _state.first; }
+
+  <%= @prefix %>state_t operator()(<%= @prefix %>state_t state) {
+    if (_states.find(state) == _states.end()) {
+      throw std::runtime_error("State not found: "s + state_names[state]);
+    }
+    return _states[state](*_data);
+  }
+
+  void operator()(<%= @prefix %>state_t from, <%= @prefix %>state_t to) {
+    if (_transitions.find(from) != _transitions.end()) {
+      if (_transitions[from].find(to) != _transitions[from].end()) {
+        _transitions[from][to](*_data);
       }
-      */
-      <% else %>
-      <% nsinks = topology[:sinks].count %>
-      #ifdef TEST_MAIN
-      #include <unistd.h>
-      int main() {
-        <%= @prefix %>state_t cur_state = <%= @prefix.upcase %>STATE_<%= @states.first[:id].upcase %>;
-      <% if @syslog then %>
-        openlog("SM", LOG_PID | LOG_PERROR, LOG_USER);
-        syslog(LOG_INFO, "Starting SM");
-      <% end %>
-        do {
-          cur_state = <%= @prefix %>run_state(cur_state, NULL);
-          sleep(1);
-      <% if nsinks == 1 %>
-        } while (cur_state != <%= @prefix.upcase %>STATE_<%= topology[:sinks][0].upcase %>);
-        <%= @prefix %>run_state(cur_state, NULL);
-      <% else %>
-        } while (1);
-      <% end %>
-        return 0;
+    }
+  }
+
+  // Run the FSM from a given state
+  void run(<%= @prefix %>state_t state, operation_fun operation = nullptr) {
+    <%= ns %>::<%= self.sigint %>_requested = false;
+    <%= @prefix %>state_t prev_state = state;
+    _state.first = state;
+    _state.second = state;
+<% if sigint then -%>
+    std::signal(SIGINT, [](int signum) {
+<% if log == :syslog then -%>
+      syslog(LOG_WARNING, "[FSM] SIGINT transition to <%= sigint %>");
+<% end -%>
+      <%= ns %>::<%= self.sigint %>_requested = true; 
+    });
+<% end -%>
+    do {
+      (*this)(_state.first, _state.second);
+      if (operation) {
+        operation(*_data);
       }
-      #endif
-      <% end %>
-    EOC
+      _state.first = _state.second;
+      _state.second = (*this)(_state.second);
+      if (_timing_func) {
+        _timing_func();
+      }
+    } while (_state.second != <%= @prefix.upcase %>STATE_<%= topology[:sinks][0].upcase %>);
+    // Call the exit state once more:
+    (*this)(<%= @prefix.upcase %>STATE_<%= topology[:sinks][0].upcase %>);
+<% if sigint then -%>
+    std::signal(SIGINT, SIG_DFL);
+<% end -%>
+  }
+
+  // Run the FSM from the initial state
+  void run(operation_fun operation = nullptr) { run(<%= @prefix.upcase %>STATE_<%= states[0][:id].upcase %>, operation); }
+
+  // install state and transition functions
+  void install_functions() {
+
+    // State functions
+<% dest = destinations.dup -%>
+<% @states.each do |s| -%>
+<% stable = true if dest[s[:id]].include? s[:id] -%>
+<% dest[s[:id]].map! {|n| (@prefix+"STATE_"+n).upcase} -%>
+<% if dest[s[:id]].empty? or stable then
+    dest[s[:id]].unshift @prefix.upcase+"NO_CHANGE"
+end -%>
+    add_state(<%= ns %>::<%= @prefix.upcase %>STATE_<%= s[:id].upcase %>, [](DATA_T &data) -> <%= ns %>::<%= @prefix %>state_t {
+<% if log == :syslog then -%>
+      syslog(LOG_INFO, "[FSM] In state <%= s[:id].upcase %>");
+<% end -%>
+      <%= ns %>::<%= @prefix %>state_t next_state = <%= @prefix%>do_<%= s[:id] %>(data);
+    
+      switch (next_state) {
+      case <%= ns %>::<%= @prefix.upcase %>UNIMPLEMENTED:
+        throw std::runtime_error("State function not fully implemented: "s + "<%= s[:id].upcase %>");
+        break;
+<% dest[s[:id]].each  do |str| -%>
+      case <%= ns %>::<%= str %>:
+<% end -%>
+        break;
+      default:
+<% if log == :syslog then -%>
+        syslog(LOG_WARNING, "[FSM] Cannot pass from <%= s[:id] %> to %s, remaining in this state", state_names[next_state]);
+<% end -%>
+        next_state = <%= ns %>::<%= @prefix.upcase %>NO_CHANGE;
+      }
+<% if sigint && stable && self.topology[:sources][0] != s[:id] then -%>
+      // SIGINT transition override
+      if (<%= self.sigint %>_requested) next_state = <%= (@prefix+"STATE_"+self.sigint ).upcase %>;
+<% end -%>
+      return next_state;
+    });
+
+<% end -%>
+
+<% if transition_functions_list.count > 0 then -%>
+    // Transition functions
+<% transition_functions_list.each do |t| -%>
+    add_transition(<%= @prefix.upcase %>STATE_<%= transitions_paths[t][0][:from].upcase %>, <%= @prefix.upcase %>STATE_<%= transitions_paths[t][0][:to].upcase %>, [](DATA_T &data) {
+<% if log == :syslog then -%>
+      syslog(LOG_INFO, "[FSM] State transition <%= t %>");
+<% end -%>
+      <%= t %>(data);
+    });
+
+<% end -%>
+<% end -%>
+  }
+
+}; // class FiniteStateMachine
+
+}; // namespace <%= @project_name || "FSM" %>
+
+#endif // <%= File::basename(@cname).upcase %>_HPP
+
+EOHPP
+
+
+    #    ____ ____  ____    ____   ___  _   _ ____   ____ _____ 
+    #   / ___|  _ \|  _ \  / ___| / _ \| | | |  _ \ / ___| ____|
+    #  | |   | |_) | |_) | \___ \| | | | | | | |_) | |   |  _|  
+    #  | |___|  __/|  __/   ___) | |_| | |_| |  _ <| |___| |___ 
+    #   \____|_|   |_|     |____/ \___/ \___/|_| \_\\____|_____|
+                                                              
+
+
+    CPP =<<~EOCPP
+<% if @syslog then -%>
+<% log = :syslog -%>
+#include <syslog.h>
+<% end -%>
+#include "<%= File::basename(@cname) %>.hpp"
+    
+using namespace std;
+<% ns = @project_name || "FSM" -%>
+    
+<% placeholder = "Your Code Here" %>
+// SEARCH FOR <%= placeholder %> FOR CODE INSERTION POINTS!
+
+
+namespace <%= @project_name || "FSM" %> {
+
+/*  ____  _        _       
+ * / ___|| |_ __ _| |_ ___ 
+ * \\___ \\| __/ _` | __/ _ \\
+ *  ___) | || (_| | ||  __/
+ * |____/ \\__\\__,_|\\__\\___|
+ *                         
+ *   __                  _   _                 
+ *  / _|_   _ _ __   ___| |_(_) ___  _ __  ___ 
+ * | |_| | | | '_ \\ / __| __| |/ _ \\| '_ \\/ __|
+ * |  _| |_| | | | | (__| |_| | (_) | | | \\__ \\
+ * |_|  \\__,_|_| |_|\\___|\\__|_|\\___/|_| |_|___/
+ */                                             
+<% dest = destinations.dup -%>
+<% topo = self.topology -%>
+<% @states.each do |s| -%>
+<% stable = true if dest[s[:id]].include? s[:id] -%>
+<% dest[s[:id]].map! {|n| (@prefix+"STATE_"+n).upcase} -%>
+<% if dest[s[:id]].empty? or stable then
+  dest[s[:id]].unshift @prefix.upcase+"NO_CHANGE"
+end %>
+// Function to be executed in state STATE_<%= s[:id].upcase %>
+// valid return states: <%= dest[s[:id]].join(", ") %>
+<% if sigint && stable && topo[:sources][0] != s[:id] then -%>
+// SIGINT triggers an emergency transition to STATE_<%= self.sigint.upcase %>
+<% end -%>
+template<class T> 
+<%= @prefix %>state_t <%= s[:function] %>(T &data) {
+  <%= @prefix %>state_t next_state = <%= ns %>::<%= @prefix.upcase %>UNIMPLEMENTED;
+  /* <%= placeholder %> */
+  
+  return next_state;
+}
+<% end -%>
+
+
+<% if transition_functions_list.count > 0 then -%>
+/*  _____                    _ _   _              
+ * |_   _| __ __ _ _ __  ___(_) |_(_) ___  _ __   
+ *   | || '__/ _` | '_ \\/ __| | __| |/ _ \\| '_ \\
+ *   | || | | (_| | | | \\__ \\ | |_| | (_) | | | | 
+ *   |_||_|  \\__,_|_| |_|___/_|\\__|_|\\___/|_| |_| 
+ *                                                
+ *   __                  _   _                 
+ *  / _|_   _ _ __   ___| |_(_) ___  _ __  ___ 
+ * | |_| | | | '_ \\ / __| __| |/ _ \\| '_ \\/ __|
+ * |  _| |_| | | | | (__| |_| | (_) | | | \\__ \\
+ * |_|  \\__,_|_| |_|\\___|\\__|_|\\___/|_| |_|___/
+ */                                              
+
+<% transition_functions_list.each do |t| -%>
+<% next if t == "NULL" -%>
+<% tpaths = transitions_paths[t] -%>
+// This function is called in <%= tpaths.count %> transition<%= tpaths.count == 1 ? '' : 's' %>:
+<% tpaths.each_with_index do |e, i| -%>
+// <%= i+1 %>. from <%= e[:from] %> to <%= e[:to] %>
+<% end -%>
+template<class T>
+void <%= t %>(T &data) {
+  /* <%= placeholder %> */
+}
+
+<% end -%>
+<% end -%>
+
+}; // namespace <%= @project_name || "FSM" %>
+
+
+<% nsinks = topology[:sinks].count -%>
+// Example usage:
+#ifdef TEST_MAIN
+#include <unistd.h>
+#include <thread>
+
+struct Data {
+  int count;
+};
+
+int main() {
+  Data data = {1};
+  auto fsm = <%= ns %>::FiniteStateMachine(&data);
+  fsm.set_timing_function([]() {
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+  });
+  fsm.run([&](Data &s) {
+    std::cout << "State: " << fsm.state() << " data: " << s.count << std::endl;
+  });
+  return 0;
+}
+#endif // TEST_MAIN
+EOCPP
+
   end
 end

data/lib/version.rb

@@ -1,3 +1,3 @@
 module GV_FSM
-  VERSION = "0.3.7"
+  VERSION = "0.4.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gv_fsm
 version: !ruby/object:Gem::Version
-  version: 0.3.7
+  version: 0.4.0
 platform: ruby
 authors:
 - Paolo Bosetti
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-08-08 00:00:00.000000000 Z
+date: 2024-10-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby-graphviz