Debugging FSA semantics

bootstrap/modelling.alc

@@ -414,6 +414,9 @@ Void function construct_model():
 		elif (command == "import_node"):
 			Element m
 			m = import_node(input())
-			dict_add(global_models, input(), m)
+			if (element_eq(m, read_root())):
+				log("Error: import not found")
+			else:
+				dict_add(global_models, input(), m)
 		else:
 			log("Modelling error: did not understand command " + command)

bootstrap/primitives.alc

@@ -80,6 +80,7 @@ Boolean function is_physical_float(a: Element) = ?primitives/is_physical_float
 Boolean function is_physical_string(a: Element) = ?primitives/is_physical_string
 Boolean function is_physical_boolean(a: Element) = ?primitives/is_physical_boolean
 Boolean function is_physical_action(a: Element) = ?primitives/is_physical_action
+Float function time() = ?primitives/time
 
 Element function exec(first_instr : Element):
 	// This does very ugly things, so beware!

integration/code/fsa_semantics.alc

@@ -22,7 +22,7 @@ Element function retype_to_runtime(design_model : Element):
 
 	runtime_model = instantiate_model(import_node("models/FiniteStateAutomata_Runtime"))
 
-	all_blocks = allInstances(design_model, "State")
+	all_states = allInstances(design_model, "State")
 	while (list_len(all_states) > 0):
 		element_name = set_pop(all_states)
 		mm_type_name = reverseKeyLookup(design_model["metamodel"]["model"], dict_read_node(design_model["type_mapping"], design_model["model"][element_name]))
@@ -70,6 +70,7 @@ Void function do_transition(model : Element, start_time : Float, event : String)
 	String cstate
 	String transition
 	String new_state
+	String raise
 
 	cstate_link = set_pop(allInstances(model, "CurrentStateLink"))
 	cstate = readAssociationDestination(model, cstate_link)
@@ -79,8 +80,8 @@ Void function do_transition(model : Element, start_time : Float, event : String)
 	Element all_transitions
 	all_transitions = allOutgoingAssociationInstances(model, cstate, "Transition")
 
-	output("SIMTIME " + cast_v2s(time() - start_time))
-	output("EVENT " + cast_v2s(event))
+	output("SIM_TIME " + cast_v2s(time() - start_time))
+	output("SIM_EVENT " + cast_v2s(event))
 
 	while (read_nr_out(all_transitions) > 0):
 		transition = set_pop(all_transitions)
@@ -91,13 +92,13 @@ Void function do_transition(model : Element, start_time : Float, event : String)
 			// Set destination of state
 			instantiate_link(model, "CurrentStateLink", "", cstate_obj, new_state)
 
-			output("STATE " + cast_v2s(new_state))
+			output("SIM_STATE " + cast_v2s(new_state))
 
 			// Raise "raise" attribute of transition
 			raise = read_attribute(model, transition, "raise")
 			if (element_neq(raise, read_root())):
 				// Raise the event
-				output("RAISE " + cast_v2s(raise))
+				output("SIM_RAISE " + cast_v2s(raise))
 
 			return !
 
@@ -134,8 +135,8 @@ Void function execute_fsa(design_model : Element):
 
 		// Process input
 		if (cmd == "skip"):
-			output("SIMTIME " + cast_v2s(time() - start_time))
-			output("STATE " + cast_v2s(readAssociationDestination(model, set_pop(allInstances(model, "CurrentStateLink")))))
+			output("SIM_TIME " + cast_v2s(time() - start_time))
+			output("SIM_STATE " + cast_v2s(readAssociationDestination(runtime_model, set_pop(allInstances(runtime_model, "CurrentStateLink")))))
 			
 		elif (cmd == "pause"):
 			// Pausing merely stops a running simulation
@@ -147,9 +148,10 @@ Void function execute_fsa(design_model : Element):
 
 			start_time = time() - simulation_time
 			output("CONTINUE")
-		
+
 		elif (cmd == "auto_sanitize"):
 			automatic_sanitization = input()
+
 		elif (cmd == "event"):
 			String evt
 			evt = input()
@@ -217,8 +219,6 @@ Void function execute_fsa(design_model : Element):
 				// Conforming, so do the retyping and sanitization step
 				runtime_model = retype_to_runtime(design_model)
 				runtime_model = sanitize(runtime_model, old_runtime_model, automatic_sanitization)
-				schedule_init = create_schedule(runtime_model)
-				schedule_run = read_root()
 				old_runtime_model = runtime_model
 				start_time = time() - simulation_time
 				output("CONFORMANCE_OK")
@@ -227,3 +227,10 @@ Void function execute_fsa(design_model : Element):
 				output("CONFORMANCE_FAIL " + conforming)
 		else:
 			log("Did not understand command: " + cmd)
+
+Void function main():
+	Element model
+	String verify_result
+
+	while (True):
+		execute_fsa(instantiate_model(import_node("models/FiniteStateAutomata_Design")))

interface/FSA/main.py

@@ -27,6 +27,7 @@ root = Tk()
 names = {}
 event_entry = StringVar()
 setting_initial = False
+request_new_state = False
 
 canvas = Canvas(root, width=MAX_WIDTH, height=MAX_HEIGHT, bg="white")
 
@@ -75,13 +76,22 @@ class FakeLayer():
     def auto_sanitize(self, auto):
         pass
 
+    def set_current(self, name):
+        pass
+
 attribute = []
 available_attrs = []
-simulation = []
+inp_evts = []
+state = []
+outp_evts = []
+
+#inp_evts = [(2, "arm"), (6, "detected")]
+#state = [(0, "idle"), (2, "armed"), (6, "detected"), (8, "idle")]
+#outp_evts = [(6, "soundAlarm"), ]
 
 def poll(address):
+    simulation_time = None
     working_available_attrs = []
-    working_simulation = None
 
     while 1:
         returnvalue = json.loads(urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "get_output", "username": username}))).read())
@@ -101,19 +111,21 @@ def poll(address):
                 v = json.loads(v)
             attribute.append(v)
         elif (returnvalue.startswith("SIM_TIME")):
-            working_simulation = (json.loads(returnvalue.split(" ", 1)[1]), {})
-        elif (returnvalue.startswith("SIM_PROBE")):
-            blockname, blockvalue = returnvalue.split(" ", 1)[1].rsplit(" ", 1)
-            working_simulation[1][json.loads(blockname)] = json.loads(blockvalue)
-        elif (returnvalue.startswith("SIM_END")):
-            simulation.append(working_simulation)
-            working_simulation = None
+            simulation_time = json.loads(returnvalue.split(" ", 1)[1])
+        elif (returnvalue.startswith("SIM_STATE")):
+            state.append((simulation_time, returnvalue.split(" ", 1)[1]))
+        elif (returnvalue.startswith("SIM_EVENT")):
+            inp_evts.append((simulation_time, returnvalue.split(" ", 1)[1]))
+        elif (returnvalue.startswith("SIM_RAISE")):
+            outp_evts.append((simulation_time, returnvalue.split(" ", 1)[1]))
         elif (returnvalue.startswith("CONFORMANCE_OK")):
             root.configure(background="grey")
         elif (returnvalue.startswith("CONFORMANCE_FAIL")):
             root.configure(background="red")
-        elif (returnvalue.startswith("ALGEBRAIC_LOOP")):
+        elif (returnvalue.startswith("REQUEST_CURRENT_STATE"):
             root.configure(background="blue")
+            global request_new_state
+            request_new_state = True
         else:
             print("Error: got unknown result: " + returnvalue)
 
@@ -184,6 +196,9 @@ class MvLayer():
         urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"auto_sanitize"', "username": username}))).read()
         urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": "true" if auto else "false", "username": username}))).read()
 
+    def set_current(self, name):
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (name), "username": username}))).read()
+
 def lower(value):
     return value / JUMP * JUMP
 
@@ -216,32 +231,37 @@ class InterfaceCore():
             # Something already there, so don't add, but modify
             lname = self.find((event.x, event.y))
 
-            attrs = self.mv.read_available_attributes(lname)
-
-            for attr, t in attrs:
-                old_value = self.mv.read_attribute(lname, attr)
-                if old_value == "None":
-                    old_value = None
-
-                new_value = tkSimpleDialog.askstring("Attribute modification", attr, initialvalue=old_value)
-                canvas.focus_set()
-                if t == "Float":
-                    new_value = float(new_value)
-                elif t == "String":
-                    new_value = str(new_value)
-                elif t == "Natural":
-                    new_value = int(new_value)
-                else:
-                    print("Got unknown type: " + str(t))
-                self.mv.set_attribute(lname, attr, new_value)
-
-                if attr == "name":
-                    if lname in names:
-                        self.canvas.delete(names[lname])
-                        del names[lname]
-                    entry = [x for x in self.drawn if str(x[4]) == str(lname)][0]
-                    xc, xy = avg(entry[0], entry[2]), avg(entry[1], entry[3])
-                    names[lname] = self.canvas.create_text(xc, xy, text=new_value)
+            if request_new_state:
+                global request_new_state
+                request_new_state = True
+                self.mv.set_current(lname)
+            else:
+                attrs = self.mv.read_available_attributes(lname)
+
+                for attr, t in attrs:
+                    old_value = self.mv.read_attribute(lname, attr)
+                    if old_value == "None":
+                        old_value = None
+
+                    new_value = tkSimpleDialog.askstring("Attribute modification", attr, initialvalue=old_value)
+                    canvas.focus_set()
+                    if t == "Float":
+                        new_value = float(new_value)
+                    elif t == "String":
+                        new_value = str(new_value)
+                    elif t == "Natural":
+                        new_value = int(new_value)
+                    else:
+                        print("Got unknown type: " + str(t))
+                    self.mv.set_attribute(lname, attr, new_value)
+
+                    if attr == "name":
+                        if lname in names:
+                            self.canvas.delete(names[lname])
+                            del names[lname]
+                        entry = [x for x in self.drawn if str(x[4]) == str(lname)][0]
+                        xc, xy = avg(entry[0], entry[2]), avg(entry[1], entry[3])
+                        names[lname] = self.canvas.create_text(xc, xy, text=new_value)
 
         else:
             global name
@@ -331,12 +351,10 @@ def add_event():
     core.add_event(event_entry.get())
 
 def control_released(evt):
-    print("Control released")
     global setting_initial
     setting_initial = False
 
 def control_pressed(evt):
-    print("Control pressed")
     global setting_initial
     setting_initial = True
 

interface/HUTN/includes/primitives.alh

@@ -90,6 +90,7 @@ Boolean function is_physical_string(a : Element)
 Boolean function is_physical_action(a : Element)
 Boolean function is_physical_boolean(a : Element)
 Boolean function has_value(a : Element)
+Float function time()
 
 Element function exec(a : Element)
 Element function resolve(var_name : String)

kernel/modelverse_kernel/primitives.py

@@ -533,3 +533,8 @@ def log(a, **remainder):
 
 def read_userroot(user_root, **remainder):
     raise PrimitiveFinished(user_root)
+
+def time(**remainder):
+    import time
+    a, = yield [("CNV", [time.time()])]
+    raise PrimitiveFinished(a)

scripts/execute_model.py

@@ -47,6 +47,7 @@ def do_compile_wrapper(filename, mode, grammar):
 initialize_SCD()
 
 for m in models:
+    print("[MODEL] %s" % m)
     do_compile_wrapper(m, "MO", "grammars/modelling.g")
 
 #p = multiprocessing.Pool(multiprocessing.cpu_count() * 2)