Add local loading page

run.py

@@ -21,6 +21,9 @@ config = None
 keeprunning = True
 arm_ready = False
 led_ready = False
+camera_ready = False
+sensor_ready = False
+vm_ready = False
 killme = None
 #pool = None
 
@@ -33,9 +36,17 @@ def led_start_callback(res):
     global led_ready
     led_ready = True
 
-def cam_start_callback(res):
-    global cam_ready
-    cam_ready = True
+def camera_start_callback(res):
+    global camera_ready
+    camera_ready = True
+    
+def sensor_start_callback(res):
+    global sensor_ready
+    sensor_ready = True
+
+def vm_start_callback(res):
+    global vm_ready
+    vm_ready = True
 
 def wait_for(val, name):
     if val is False:
@@ -43,23 +54,34 @@ def wait_for(val, name):
         while val is False:
             sleep(0.1)
 
-def setup(pool):
+def setup_server(pool):
+    # linux server setup
     global config
     global counter
+    global sensor_ready
+    global camera_ready
+    global led_ready
+    global arm_ready
+
     fprint("Starting Jukebox control system...")
     pool.apply_async(ur5_control.init, (config["arm"]["ip"],), callback=arm_start_callback)
     #pool.apply_async(led_control.init, callback=led_start_callback)
-    #pool.apply_async(cam_control.init, callback=led_start_callback)
+    #pool.apply_async(camera_control.init, callback=camera_start_callback)
+    #pool.apply_async(sensor_control.init, callback=sensor_start_callback)
 
     wait_for(led_ready, "LED controller initialization")
+    wait_for(sensor_ready, "Sensor Initialization")
+    wait_for(camera_ready, "Camera initilization")
     wait_for(arm_ready, "UR5 initilization")
-    wait_for(cam_ready, "Camera initilization")
+    
+    
+    
         
     return True
 
 
 
-def mainloop(pool):
+def mainloop_server(pool):
     global config
     global counter
     global killme
@@ -68,7 +90,40 @@ def mainloop(pool):
         killall()
     counter = counter + 1
 
-class Logger(object):
+
+
+def setup_client(pool, config):
+    # Windows client setup
+
+    # Open loading wepage
+    def run_app():
+        from flask import Flask, render_template
+        app = Flask(__name__)
+
+        @app.route('/')
+        def index():
+            return render_template('index.html')
+        
+        app.run(debug=True, use_reloader=False)
+    
+    p = Process(target=run_app)
+    p.start()
+    # start Linux server VM
+    if config["core"]["server"] == "Hyper-V":
+        run_cmd("Start-VM -Name Jukebox*") # any and all VMs starting with "Jukebox"
+
+    # Wait for VM to start and be reachable over the network
+    #pool.apply_async(vm_control.init, callback=vm_start_callback)
+
+    wait_for(vm_ready, "VM Startup")
+    p.terminate()
+    return True
+    
+
+def mainloop_client(pool):
+    sleep(0.1)
+
+"""class Logger(object):
     def __init__(self, filename="output.log"):
         self.log = open(filename, "a")
         self.terminal = sys.stdout
@@ -83,10 +138,7 @@ class Logger(object):
             sleep(0)
         
     def flush(self):
-        print("",end="")
-
-
-
+        print("",end="")"""
 
 def killall():
     procs = active_children()
@@ -140,8 +192,14 @@ if __name__ == "__main__":
         counter = 0
         killme = manager.Value('d', 0)
         signal.signal(signal.SIGINT, killall_signal)
-        if setup(pool):
-            while(keeprunning):
-                mainloop(pool)
+        if config["core"]["mode"] == "winclient":
+            if setup_client(pool, config):
+                while(keeprunning):
+                    mainloop_client(pool)
+
+        elif config["core"]["mode"] == "linuxserver":
+            if setup_server(pool):
+                while(keeprunning):
+                    mainloop_server(pool)