script/devices/Hexiposi.py

@@ -13,6 +13,7 @@ class Hexiposi(DiscretePositionerBase):
          self.moved = True     
          self.homing_state = State.Disabled
          self.rback = self.UNKNOWN_POSITION 
+         self.timeout = 3.0
 
     def doInitialize(self):           
         super(Hexiposi, self).doInitialize()
@@ -24,7 +25,7 @@ class Hexiposi(DiscretePositionerBase):
         return json.loads(response.text)
 
     def get_status(self):
-        self.status =  self.get_response(requests.get(url=self.url+"get"))
+        self.status =  self.get_response(requests.get(url=self.url+"get", timeout=self.timeout))
         self.estop = self.status["estop"]
         self.homed = self.status["homed"]
         self.error = self.status["errorCode"]
@@ -48,10 +49,10 @@ class Hexiposi(DiscretePositionerBase):
         return self.status
 
     def move_pos(self, pos):        
-        return self.get_response(requests.get(url=self.url+"set?pos=" + str(pos)))
+        return self.get_response(requests.get(url=self.url+"set?pos=" + str(pos), timeout=self.timeout))
 
     def move_home(self):                
-        ret = self.get_response(requests.get(url=self.url+"set?home=1"))
+        ret = self.get_response(requests.get(url=self.url+"set?home=1", timeout=self.timeout))
         try:
             self.waitState(self.homing_state,1200)                
         except:
@@ -59,10 +60,10 @@ class Hexiposi(DiscretePositionerBase):
         return ret
 
     def stop_move(self):
-        return self.get_response(requests.get(url=self.url+"set?stop=1"))
+        return self.get_response(requests.get(url=self.url+"set?stop=1", timeout=self.timeout))
 
     def set_offset(self, offset):
-        return self.get_response(requests.get(url=self.url+"setOffset?offset="+str(offset)))
+        return self.get_response(requests.get(url=self.url+"setOffset?offset="+str(offset), timeout=self.timeout))
      
     def doUpdate(self):
         self.get_status()

script/devices/RobotSC.py

@@ -24,7 +24,7 @@ class RobotSC(RobotTCP):
     def __init__(self, name, server, timeout = 1000, retries = 1):
         RobotTCP.__init__(self, name, server, timeout, retries)   
         self.set_tasks(["getDewar", "putDewar", "putGonio", "getGonio", "robotRecover", "moveDewar", "movePark", "moveGonio","moveHeater", "moveScanner"])
-        self.set_known_points(["pHome", "pPark", "pDewarHome", "pGonioHome", "pDewarWait", "pGonioGet", "pScanHome", "pHeaterHome"])
+        self.set_known_points(["pHome", "pPark", "pDewarHome", "pGonioHome", "pDewarWait", "pGonioGet", "pScanHome", "pHeaterHome", "pHeater", "pHeaterBottom"])
         self.setPolling(DEFAULT_ROBOT_POLLING)              
         
     def move_dewar(self):
@@ -65,15 +65,23 @@ class RobotSC(RobotTCP):
         self.wait_task_finished(TASK_WAIT_ROBOT_POLLING)    
         self.assert_gonio()
 
+    def move_home(self):
+        self.start_task('moveHome')   
+        self.wait_task_finished(TASK_WAIT_ROBOT_POLLING)    
+        self.assert_home()    
+
     def move_park(self):
         self.start_task('movePark')   
         self.wait_task_finished(TASK_WAIT_ROBOT_POLLING)    
         self.assert_park()
 
-    def move_heater(self):
-        self.start_task('moveHeater')   
+    def move_heater(self, speed=-1, to_bottom=True):
+        self.start_task('moveHeater', speed, to_bottom)   
         self.wait_task_finished(TASK_WAIT_ROBOT_POLLING)    
-        self.assert_heater()
+        if to_bottom:
+            self.assert_heater_bottom()
+        else:
+            self.assert_heater()
 
 
     def robot_recover(self):
@@ -134,7 +142,13 @@ class RobotSC(RobotTCP):
         return  self.is_in_point("pDewarWait")   
 
     def is_heater(self):
-        return  self.is_in_point("pHeaterHome")   
+        return  self.is_in_point("pHeater")   
+
+    def is_heater_home(self):
+        return  self.is_in_point("pHeaterHome")  
+
+    def is_heater_bottom(self):
+        return  self.is_in_point("pHeaterBottom")   
 
     def is_gonio(self):
         return  self.is_in_point("pGonioHome")   
@@ -149,9 +163,15 @@ class RobotSC(RobotTCP):
     def assert_home(self):
         self.assert_in_point("pHome")    
 
-    def assert_heater(self):
+    def assert_heater_home(self):
         self.assert_in_point("pHeaterHome") 
     
+    def assert_heater(self):
+        self.assert_in_point("pHeater") 
+
+    def assert_heater_bottom(self):
+        self.assert_in_point("pHeaterBottom")
+
     def assert_park(self):
         self.assert_in_point("pPark")   
     

script/devices/RobotTCP.py

@@ -43,6 +43,7 @@ class RobotTCP(TcpDevice, Stoppable):
          self.frame = FRAME_DEFAULT
          self.polling_interval = 0.01
          self.reset = True           
+         self.default_tolerance = 10         
 
          self.task_start_retries = 3
          self.exception_on_task_start_failure = True  #Tasks may start and be finished when checked
@@ -454,8 +455,12 @@ class RobotTCP(TcpDevice, Stoppable):
 
         #taskCreate "t1", 10, read(sMessage)
         cmd = 'taskCreate "' + name + '", ' + str(priority) + ', ' + program + '('
-        for i in range(len(args)):            
-            cmd += str(args[i]) + (',' if  (i<(len(args)-1)) else '')
+        for i in range(len(args)): 
+            val = args[i]
+            if type(val) == bool:
+                if val == True: val = "true"
+                elif val == False: val = "false"
+            cmd += str(val) + (',' if  (i<(len(args)-1)) else '')
         cmd+=')'
         self.evaluate(cmd)
         
@@ -574,7 +579,7 @@ class RobotTCP(TcpDevice, Stoppable):
         return  self.distance_p("tcp_p", name)
 
     def is_in_point(self, p, tolerance = None): #Tolerance in mm
-        tolerance = 10 if tolerance == None else tolerance
+        tolerance = self.default_tolerance if tolerance == None else tolerance
         d = self.get_distance_to_pnt(p)
         if d<0:
             raise Exception ("Error calculating distance to " + p + " : " + str(d))
@@ -589,9 +594,9 @@ class RobotTCP(TcpDevice, Stoppable):
             except:
                 ret[i] = None         
         return ret
-        
+
     def is_in_points(self, *pars, **kwargs): #Tolerance in mm
-        tolerance = 10 if (kwargs is None) or (not kwargs.has_key("tolerance")) or (kwargs["tolerance"] is None) else kwargs["tolerance"]                
+        tolerance = self.default_tolerance if (kwargs is None) or (not kwargs.has_key("tolerance")) or (kwargs["tolerance"] is None) else kwargs["tolerance"]                
         ret = self.get_distance_to_pnts(*pars)
         for i in range(len(ret)):        
             if ret[i]<0:

script/local.py

@@ -35,6 +35,13 @@ run("motion/get_dewar")
 run("motion/put_dewar")
 run("motion/get_gonio")
 run("motion/put_gonio")
+run("motion/move_dewar")
+run("motion/move_gonio")
+run("motion/move_heater")
+run("motion/move_home")
+run("motion/move_park")
+run("motion/move_scanner")
+run("motion/dry")
 run("motion/homing_hexiposi")
 run("imgproc/Utils")
 run("tools/Math")
@@ -66,6 +73,13 @@ def stop_puck_detection():
 #  Device initialization
 ###################################################################################################
 
+try:
+    set_heater(False)
+    set_air_stream(False)
+except:
+   print  >> sys.stderr, traceback.format_exc() 
+
+
 try:
     release_local_safety.write(False)
     release_psys_safety.write(False)
@@ -109,7 +123,6 @@ except:
    print  >> sys.stderr, traceback.format_exc()    
 
 
-
 ###################################################################################################
 #  Global variables
 ###################################################################################################

script/motion/dry.py

@@ -0,0 +1,55 @@
+
+def set_air_stream(state):
+    """
+    """
+    valve_1.write(state)
+    valve_2.write(not state)
+
+
+def set_heater(state):
+    """
+    """
+    gripper_dryer.write(state)
+
+
+def get_air_stream():
+    """
+    """
+    return valve_1.read()
+
+
+def get_heater():
+    """
+    """
+    return gripper_dryer.read()
+
+
+
+def dry(heat_time, speed):    
+    """
+        heat_time (float): in seconds
+        speed (float): % of nominal speed
+    """
+    print "dry"
+    #Initial checks
+    robot.assert_no_task()
+    robot.reset_motion()
+    robot.state.assertReady()
+    robot.assert_cleared()
+    #robot.assert_in_known_point()
+
+    #Enabling
+    enable_motion()    
+
+    try:
+        set_heater(True)
+        robot.move_heater(speed, False)    
+        time.sleep(heat_time)
+        robot.move_heater(speed, True)    
+        set_air_stream(True)        
+        robot.move_heater(speed, False)    
+    finally:
+        set_heater(False)
+        set_air_stream(False)
+
+    robot.move_dewar()  

script/motion/mount.py

@@ -2,7 +2,7 @@ def mount(segment, puck, sample, force=False):
     """
     """
     print "mount: ", segment, puck, sample, force
-    
+    start = time.time()
     #Initial checks
     assertValidAddress(segment, puck, sample)
     robot.assert_no_task()

script/motion/move_dewar.py

@@ -0,0 +1,18 @@
+def move_dewar():
+    """
+    """
+    print "move_dewar"
+    
+    #Initial checks
+    robot.assert_no_task()
+    robot.reset_motion()
+    robot.state.assertReady()
+    robot.assert_cleared()
+    #robot.assert_in_known_point()
+
+    #Enabling
+    enable_motion()
+
+
+    if not robot.is_dewar():
+        robot.move_dewar()  

script/motion/move_gonio.py

@@ -0,0 +1,18 @@
+def move_gonio():
+    """
+    """
+    print "move_gonio"
+    
+    #Initial checks
+    robot.assert_no_task()
+    robot.reset_motion()
+    robot.state.assertReady()
+    robot.assert_cleared()
+    #robot.assert_in_known_point()
+
+    #Enabling
+    enable_motion()
+
+
+    if not robot.is_gonio():
+        robot.move_gonio()

script/motion/move_heater.py

@@ -0,0 +1,18 @@
+def move_heater():
+    """
+    """
+    print "move_heater"
+    
+    #Initial checks
+    robot.assert_no_task()
+    robot.reset_motion()
+    robot.state.assertReady()
+    robot.assert_cleared()
+    #robot.assert_in_known_point()
+
+    #Enabling
+    enable_motion()
+
+
+    if not robot.is_heater():
+        robot.move_heater()

script/motion/move_home.py

@@ -0,0 +1,18 @@
+def move_home():
+    """
+    """
+    print "move_home"
+    
+    #Initial checks
+    robot.assert_no_task()
+    robot.reset_motion()
+    robot.state.assertReady()
+    robot.assert_cleared()
+    #robot.assert_in_known_point()
+
+    #Enabling
+    enable_motion()
+
+
+    if not robot.is_home():
+        robot.move_home()

script/motion/move_park.py

@@ -0,0 +1,18 @@
+def move_park():
+    """
+    """
+    print "move_park"
+    
+    #Initial checks
+    robot.assert_no_task()
+    robot.reset_motion()
+    robot.state.assertReady()
+    robot.assert_cleared()
+    #robot.assert_in_known_point()
+
+    #Enabling
+    enable_motion()
+
+
+    if not robot.is_park():
+        robot.move_park()  

script/motion/move_scanner.py

@@ -0,0 +1,18 @@
+def move_scanner():
+    """
+    """
+    print "move_scanner"
+    
+    #Initial checks
+    robot.assert_no_task()
+    robot.reset_motion()
+    robot.state.assertReady()
+    robot.assert_cleared()
+    #robot.assert_in_known_point()
+
+    #Enabling
+    enable_motion()
+
+
+    if not robot.is_scanner():
+        robot.move_scanner()