script/devices/Hexiposi.py

@@ -9,7 +9,10 @@ class Hexiposi(DiscretePositionerBase):
              url = "http://" + url
          if not url.endswith("/"):
              url =  url + "/"
-         self.url = url           
+         self.url = url      
+         self.moved = True     
+         self.homing_state = State.Disabled
+         self.rback = self.UNKNOWN_POSITION 
 
     def doInitialize(self):           
         super(Hexiposi, self).doInitialize()
@@ -31,21 +34,29 @@ class Hexiposi(DiscretePositionerBase):
         self.moving = self.status["moving"]
         self.offset = self.status["offset"]        
         self.dpos = self.status["discretePosition"]    
-        if (self.homed==False): self.rback =  self.UNKNOWN_POSITION 
-        elif self.dpos == 1: self.rback = "A"
-        elif self.dpos == 2: self.rback = "B"
-        elif self.dpos == 4: self.rback = "C"
-        elif self.dpos == 8: self.rback = "D"
-        elif self.dpos == 16: self.rback = "E"
-        elif self.dpos == 32: self.rback = "F"
-        else: self.rback = self.UNKNOWN_POSITION 
+        if (self.homed==False): rback =  self.UNKNOWN_POSITION 
+        elif self.dpos == 1: rback = "A"
+        elif self.dpos == 2: rback = "B"
+        elif self.dpos == 4: rback = "C"
+        elif self.dpos == 8: rback = "D"
+        elif self.dpos == 16: rback = "E"
+        elif self.dpos == 32: rback = "F"
+        else: rback = self.UNKNOWN_POSITION 
+        if (rback == self.UNKNOWN_POSITION) or (rback != self.rback):
+            self.moved = True
+        self.rback = rback
         return self.status
 
-    def move_pos(self, pos):
+    def move_pos(self, pos):        
         return self.get_response(requests.get(url=self.url+"set?pos=" + str(pos)))
 
-    def move_home(self):        
-        return self.get_response(requests.get(url=self.url+"set?home=1"))
+    def move_home(self):                
+        ret = self.get_response(requests.get(url=self.url+"set?home=1"))
+        try:
+            self.waitState(self.homing_state,1200)                
+        except:
+            pass
+        return ret
 
     def stop_move(self):
         return self.get_response(requests.get(url=self.url+"set?stop=1"))
@@ -82,16 +93,26 @@ class Hexiposi(DiscretePositionerBase):
             except:
                 pass
 
-    def assert_in_position(self, pos):
+    def is_in_position(self, pos):
         return take() == pos
 
+
+    def assert_in_position(self, pos):
+        if not is_in_position(pos):
+            raise Exception ("Hexiposi is not in position")
+    
+    def assert_homed(self):
+        if self.homed == False:
+            raise Exception ("Hexiposi is not homed")
+        
+
     #def isReady(self):
     #    self.get_status()
     #    return self.moving == False
     
     def updateState(self):   
         if self.homed == False:
-            self.setState(State.Disabled)            
+            self.setState(self.homing_state)            
         elif self.moving: 
             self.setState(State.Busy)            
         else:

script/devices/RobotSC.py

@@ -23,13 +23,17 @@ joint_forces = False
 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"])
-        self.setPolling(DEFAULT_ROBOT_POLLING)      
-        self.known_points = ["pHome", "pPark", "pDewarHome", "pGonioHome", "pDewarWait", "pGonioGet", "pScanHome", "pHeaterHome"]
+        self.set_tasks(["getDewar", "putDewar", "putGonio", "getGonio", "robotRecover", "moveDewar", "movePark", "moveGonio","moveHeater"])
+        self.set_known_points(["pHome", "pPark", "pDewarHome", "pGonioHome", "pDewarWait", "pGonioGet", "pScanHome", "pHeaterHome"])
+        self.setPolling(DEFAULT_ROBOT_POLLING)              
         
+    def move_dewar(self):
+        self.start_task('moveDewar')  
+        self.wait_task_finished(TASK_WAIT_ROBOT_POLLING)    
+        self.assert_dewar()
+
     def get_dewar(self, segment, puck, sample):
         segment = self.toSegmentNumber(segment)
-        self.assert_dewar()
         self.start_task('getDewar',segment, puck, sample) 
         self.wait_task_finished(TASK_WAIT_ROBOT_POLLING)    
         self.assert_dewar()
@@ -42,31 +46,38 @@ class RobotSC(RobotTCP):
         self.assert_dewar()
 
     def put_gonio(self):    
-        self.start_task('putGonio',segment, puck, sample) 
+        self.start_task('putGonio') 
         self.wait_task_finished(TASK_WAIT_ROBOT_POLLING)    
-        #TODO
+        self.assert_gonio()
 
     def get_gonio(self):
         self.start_task('getGonio') 
         self.wait_task_finished(TASK_WAIT_ROBOT_POLLING)    
-        #TODO
+        self.assert_gonio()
 
-    def robot_recover(self):
-        self.start_task('robotRecover')
+    def move_gonio(self):
+        self.start_task('moveGonio') 
         self.wait_task_finished(TASK_WAIT_ROBOT_POLLING)    
-
-    def move_dewar_wait(self):
-        self.start_task('moveDewar')  
-        self.wait_task_finished(TASK_WAIT_ROBOT_POLLING)    
-        self.assert_dewar_wait()
+        self.assert_gonio()
 
     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')   
+        self.wait_task_finished(TASK_WAIT_ROBOT_POLLING)    
+        self.assert_heater()
+
+
+    def robot_recover(self):
+        self.start_task('robotRecover')
+        self.wait_task_finished(TASK_WAIT_ROBOT_POLLING)    
+        self.assert_dewar_home()
+
     def toSegmentNumber(self, segment):
-        if type(segment) == str:
+        if is_string(segment):
             segment = ord(segment.upper()) - ord('A') +1
         return segment
     
@@ -74,6 +85,9 @@ class RobotSC(RobotTCP):
     def on_event(self,ev):
         #print "EVT: " + ev
         pass
+    def on_change_working_mode(self, working_mode):
+        if get_device("hexiposi") is not None:
+            hexiposi.moved = True    #Force image processing on first sample
     
     def doUpdate(self):    
         #start = time.time()        
@@ -111,17 +125,24 @@ class RobotSC(RobotTCP):
     def is_dewar_home(self):
         return  self.is_in_point("pDewarHome")
 
-    def is_dewar_wait(self):
+    def is_dewar(self):
         return  self.is_in_point("pDewarWait")   
 
+    def is_heater(self):
+        return  self.is_in_point("pHeaterHome")   
+
     def is_gonio(self):
         return  self.is_in_point("pGonioHome")   
                 
     def is_cleared(self):
-        return self.is_home() or self.is_park() or self.is_dewarHome() or self.is_dewarWait()
+        #return self.is_home() or self.is_park() or self.is_dewar() or self.is_dewar_home()        
+        return self.get_current_point() is not None
 
     def assert_home(self):
-        self.assert_in_point("pHome")       
+        self.assert_in_point("pHome")    
+
+    def assert_heater(self):
+        self.assert_in_point("pHeaterHome") 
     
     def assert_park(self):
         self.assert_in_point("pPark")   
@@ -129,7 +150,7 @@ class RobotSC(RobotTCP):
     def assert_dewar_home(self):
         self.assert_in_point("pDewarHome")
 
-    def assert_dewar_wait(self):
+    def assert_dewar(self):
         self.assert_in_point("pDewarWait")   
 
     def assert_gonio(self):
@@ -137,16 +158,7 @@ class RobotSC(RobotTCP):
 
     def assert_cleared(self):
         if not self.is_cleared():
-            raise Exception("Robot not in cleared position")
-
-    def get_current_point(self):      
-        ret = robot.is_in_points(*self.known_points, tolerance = 20)
-        for i in range(len(ret)):
-            if ret[i] == True:
-                return self.known_points[i]
-        return None
-
-        
+            raise Exception("Robot not in cleared position")        
 
 if simulation:
     #add_device(RobotSC("robot","129.129.126.92:1000"),force = True)

script/devices/RobotTCP.py

@@ -27,7 +27,8 @@ class RobotTCP(TcpDevice, Stoppable):
          self.joint_forces = None
          self.current_task = None         
          self.current_task_ret = None
-         self.high_level_tasks = []         
+         self.high_level_tasks = []    
+         self.known_points = []     
          self.cartesian_destination = None  
          #self.flange_pos = [None] * 6
          self.cartesian_pos = [None] * 6
@@ -79,6 +80,23 @@ class RobotTCP(TcpDevice, Stoppable):
     def get_tasks(self):    
         return self.high_level_tasks
 
+    def set_known_points(self, points):
+        self.known_points=points
+    
+    def get_known_points(self):    
+        return self.known_points
+
+    def get_current_point(self, tolerance = None):      
+        ret = self.is_in_points(*self.known_points, tolerance = tolerance)
+        for i in range(len(ret)):
+            if ret[i] == True:
+                return self.known_points[i]
+        return None
+
+    def assert_in_known_point(self, tolerance = None):
+        if self.get_current_point(tolerance) is None:
+            raise Exception ("Robot not in known point")        
+
     def _sendReceive(self, msg_id, msg = "", timeout =  None):  
         tx = self.header if (self.header != None) else  ""
         tx = tx + msg_id + " " + msg        
@@ -262,6 +280,7 @@ class RobotTCP(TcpDevice, Stoppable):
         if str(ret) != "0": raise Exception("Error saving program: " + str(ret))
             
     def _update_working_mode(self, mode, status):
+        cur_mode = self.working_mode
         if mode==1:                 
             self.working_mode = "manual"
             self.status = "hold" if status==6 else "move"
@@ -277,6 +296,11 @@ class RobotTCP(TcpDevice, Stoppable):
         else:
             self.working_mode = "invalid"
             self.status = "invalid"
+        if self.working_mode != cur_mode:
+            try:
+                self.on_change_working_mode(self.working_mode)
+            except:
+                pass
     
     def read_working_mode(self):
         try:
@@ -422,7 +446,7 @@ class RobotTCP(TcpDevice, Stoppable):
     #Task control
     def task_create(self, program, *args,  **kwargs):        
         program = str(program)
-        priority = 10 if (kwargs is None) or (not kwargs.has_key("priority")) else kwargs["priority"]                
+        priority = 10 if (kwargs is None) or (not kwargs.has_key("priority")) or (kwargs["priority"] is None) else kwargs["priority"]                
         name = str(program if (kwargs is None) or (not kwargs.has_key("name")) else kwargs["name"])                
         
         if self.get_task_status(name)[0] != -1:
@@ -549,7 +573,8 @@ class RobotTCP(TcpDevice, Stoppable):
         self.get_cartesian_pos() 
         return  self.distance_p("tcp_p", name)
 
-    def is_in_point(self, p, tolerance = 20): #Tolerance in mm
+    def is_in_point(self, p, tolerance = None): #Tolerance in mm
+        tolerance = 10 if tolerance == None else tolerance
         d = self.get_distance_to_pnt(p)
         if d<0:
             raise Exception ("Error calculating distance to " + p + " : " + str(d))
@@ -566,7 +591,7 @@ class RobotTCP(TcpDevice, Stoppable):
         return ret
         
     def is_in_points(self, *pars, **kwargs): #Tolerance in mm
-        tolerance = 20 if (kwargs is None) or (not kwargs.has_key("tolerance")) else kwargs["tolerance"]                
+        tolerance = 10 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:
@@ -575,7 +600,7 @@ class RobotTCP(TcpDevice, Stoppable):
                 ret[i] = ret[i]<tolerance
         return ret
              
-    def assert_in_point(self, p, tolerance = 20): #Tolerance in mm         
+    def assert_in_point(self, p, tolerance = None): #Tolerance in mm         
         if not self.is_in_point(p, tolerance):
             raise Exception ("Not in position " + p)
 
@@ -632,7 +657,7 @@ class RobotTCP(TcpDevice, Stoppable):
         return np
         
     #High-level, exclusive motion task.
-    def start_task(self, program, *args,  **kwargs):        
+    def start_task(self, program, *args,  **kwargs):    
         tasks = [t for t in self.high_level_tasks]
         if (self.current_task is not None) and (not self.current_task in tasks): 
             tasks.append(self.current_task)
@@ -655,18 +680,18 @@ class RobotTCP(TcpDevice, Stoppable):
             if i < self.task_start_retries-1:
                 ret = self.get_task_ret(False)
                 if ret == 0: #Did't start
-                    log("Retrying starting : " + str(program) + " - status: " + str(status) + " (" + str(code) + ")", False)        
-                    print "Retrying starting : " + str(program) + " - status: " + str(status) + " (" + str(code) + ")"                
+                    log("Retrying starting : " + str(program) + str(args) + " - status: " + str(status) + " (" + str(code) + ")", False)        
+                    print "Retrying starting : " + str(program) + str(args) + " - status: " + str(status) + " (" + str(code) + ")"                
                 else :
-                    print "Retrying aborted : " + str(program) + " - ret: " + str(ret) + " - status: " + str(status) + " (" + str(code) + ")"                
+                    print "Retrying aborted : " + str(program) + str(args) + " - ret: " + str(ret) + " - status: " + str(status) + " (" + str(code) + ")"                
                     break
             else:
-                log("Failed starting : " + str(program), False)       
-                print "Failed starting : " + str(program) 
+                log("Failed starting : " + str(program) + str(args), False)       
+                print "Failed starting : " + str(program)  + str(args)
                 if self.exception_on_task_start_failure:
-                    raise Exception("Cannot start task: " + task)                                
+                    raise Exception("Cannot start task: " + program + + str(args))                                
                               
-        log("Task started: " + str(program) + " - status: " + str(status) + " (" + str(code) + ")", False)        
+        log("Task started: " + str(program) + str(args) + " - status: " + str(status) + " (" + str(code) + ")", False)        
         self.current_task, self.current_task_ret  = program, None
         self.update()               
         #self._update_state()
@@ -684,8 +709,8 @@ class RobotTCP(TcpDevice, Stoppable):
             tasks.append(self.current_task)
         for task in tasks:
             #if self.get_task_status(task)[0]>=0:                
-                self.task_kill(task)                
-
+                self.task_kill(task)             
+        self.reset_motion()   
 
     def get_task_ret(self, cached = True):
         return self.current_task_ret if cached else self.eval_int("tcp_ret")        
@@ -713,8 +738,9 @@ class RobotTCP(TcpDevice, Stoppable):
                 time.sleep(self.polling_interval)  
         finally:
             if polling is not None:
-                self.polling = cur_polling
-        return self.get_task_ret()
+                self.polling = cur_polling        
+        ret = self.get_task_ret()        
+        return ret
 
     def assert_no_task(self):
         task = self.check_task()
@@ -723,5 +749,7 @@ class RobotTCP(TcpDevice, Stoppable):
         
     def on_event(self,ev):
         pass
-                    
+
+    def on_change_working_mode(self, working_mode):
+        pass
             

script/imgproc/CoverDetection2.py

@@ -9,8 +9,7 @@ POSITION_NAMES = [ 'A','B','C','D', 'E', 'F']
 POSITION_ANGLES = [330, 30, 90, 150, 210, 270]
 POSITION_TOLERANCE = 3
 MINIMUM_CONFIDENCE = 10
-DEBUG = True
-PLOT = True
+DEBUG = cover_detection_debug
 REFERENCE_IMG = "ref2"
 
 #Load reference image
@@ -28,7 +27,8 @@ cx,cy = int(ip.width/2), int(ip.height/2)
 ip = sub_image(ip, cx-ref.width/2, cy-ref.height/2, ref.width, ref.height)
 
 #Show ROI of pre-processed image 
-image_panel = show_panel(ip.bufferedImage)
+if DEBUG:
+    image_panel = show_panel(ip.bufferedImage)
 
 
 #Calculate correlation between image and reference, rotating the reference from 0 to 360
@@ -43,8 +43,6 @@ for i in xdata:
     bi = op.getBufferedImage()
     p = integrateVertically(bi)
     ydata.append(sum(p))
-    #image_panel = show_panel(op.bufferedImage)
-    #time.sleep(1.0)
 
 
 #Calculate angle of the highest correlation, and confidence level
@@ -62,7 +60,7 @@ if angle is not None:
             position = POSITION_NAMES[i]
 
 #Plot the correlations values  agains angle
-if PLOT:
+if DEBUG:
     p = plot(ydata, xdata=xdata)[0]
 
 #Output results

script/imgproc/Utils.py

@@ -18,9 +18,13 @@ def get_img_cover_pos():
 def assert_img_in_cover_pos(pos = None):
     if pos==None: 
         pos = hexiposi.take()
+    elif type(pos) is int:
+        pos = chr( ord('A') + (pos-1))
+    elif type(pos) is str:
+        pos = pos.upper()    
     img_segment = get_img_cover_pos()
-    if img_segment != segment:
-        raise Excepton ("Image detection of cover does not match hexiposi: " + str(img_segment))
+    if img_segment != pos:
+        raise Exception ("Image detection of cover does not match position: " + str(img_segment))
     
 
 def in_roi(x,y):

script/local.py

@@ -31,6 +31,11 @@ add_device(img.getCamera(), force = True)
 run("motion/tools")
 run("motion/mount")
 run("motion/unmount")
+run("motion/get_dewar")
+run("motion/put_dewar")
+run("motion/get_gonio")
+run("motion/put_gonio")
+run("motion/homing_hexiposi")
 run("imgproc/Utils")
 run("tools/Math")
 
@@ -56,8 +61,8 @@ try:
     release_local_safety.write(False)
     release_psys_safety.write(False)
 except:
-   print  >> sys.stderr, traceback.format_exc()    
-
+   print  >> sys.stderr, traceback.format_exc()
+   
 try:
     hexiposi.polling=500    
 except:
@@ -103,6 +108,8 @@ except:
 
 context = get_context()
 
+cover_detection_debug = False
+
 
 
 update()

script/motion/get_dewar.py

@@ -0,0 +1,28 @@
+def get_dewar(segment, puck, sample, force=False):
+    """
+    """
+    print "get_dewar: ", segment, puck, sample, force
+    
+    #Initial checks
+    assertValidAddress(segment, puck, sample)
+    robot.assert_no_task()
+    robot.reset_motion()
+    robot.state.assertReady()
+    robot.assert_cleared()
+    #robot.assert_in_known_point()
+    hexiposi.assert_homed()
+    #location = robot.get_current_point()
+    
+
+    #Enabling
+    enable_motion()
+    
+    set_hexiposi(segment)
+    
+    if not force:        
+        visual_check_hexiposi(segment)           
+
+    if not robot.is_dewar():
+        robot.move_dewar()      
+            
+    robot.get_dewar(segment, puck, sample)

script/motion/get_gonio.py

@@ -0,0 +1,20 @@
+def get_gonio(force=False):
+    """
+    """
+    print "get_gonio: ", force
+    
+    #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()
+            
+    robot.get_gonio()

script/motion/homing_hexiposi.py

@@ -0,0 +1,15 @@
+def homing_hexiposi():
+    """
+    """
+    print "homing_hexiposi"
+    
+    #Initial checks
+    robot.assert_no_task()
+    robot.state.assertReady()
+    robot.assert_cleared()
+    #robot.assert_in_known_point()
+    #location = robot.get_current_point()
+
+    hexiposi.move_home()
+    hexiposi.waitState(State.Ready,-1)    
+    

script/motion/mount.py

@@ -6,35 +6,25 @@ def mount(segment, puck, sample, force=False):
     #Initial checks
     assertValidAddress(segment, puck, sample)
     robot.assert_no_task()
+    robot.reset_motion()
     robot.state.assertReady()
     robot.assert_cleared()
-
-    if hexiposi.homed == False:
-        raise Exception ("Hexiposi is not homed")
+    #robot.assert_in_known_point()
+    hexiposi.assert_homed()
+    #location = robot.get_current_point()
 
     #Enabling
     enable_motion()
     
     set_hexiposi(segment)
-
     
-    if not force:
-        #Clearing for image processing
-        robot.move_park()        
-        assert_img_in_cover_pos(segment)
-    
-    location = robot.get_current_point()
-    print "Location: " + location
+    if not force:        
+        visual_check_hexiposi(segment)           
 
-    robot.move_dewar_wait()        
-    try:
-        robot.get_dewar(segment, puck, sample)
-    except:
-        #robot.move_dewar()        
-        raise
-
-    try:
-        robot.put_gonio()    
-    except:        
-        #TODO: recover
-        raise
+    if not robot.is_dewar():
+        robot.move_dewar()      
+            
+    robot.get_dewar(segment, puck, sample)
+    robot.move_gonio()    
+    robot.put_gonio()    
+    robot.move_dewar()        

script/motion/put_dewar.py

@@ -0,0 +1,28 @@
+def put_dewar(segment, puck, sample, force=False):
+    """
+    """
+    print "put_dewar: ", segment, puck, sample, force
+    
+    #Initial checks
+    assertValidAddress(segment, puck, sample)
+    robot.assert_no_task()
+    robot.reset_motion()
+    robot.state.assertReady()
+    robot.assert_cleared()
+    #robot.assert_in_known_point()
+    hexiposi.assert_homed()
+
+    #Enabling
+    enable_motion()
+
+    set_hexiposi(segment)
+
+    if not force:        
+        visual_check_hexiposi(segment)
+
+    #location = robot.get_current_point()
+
+    if not robot.is_dewar():
+        robot.move_dewar()      
+
+    robot.put_dewar(segment, puck, sample)

script/motion/put_gonio.py

@@ -0,0 +1,18 @@
+def put_gonio(segment, puck, sample, force=False):
+    """
+    """
+    print "put_gonio: ", force
+    
+    #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()
+    robot.put_gonio()    

script/motion/tools.py

@@ -34,7 +34,17 @@ def set_hexiposi(pos):
             set_status(None)    
     else:
         hexiposi.move(pos)
-    
+
+def visual_check_hexiposi(segment):
+    #if robot.working_mode == "manual" ?
+    if hexiposi.moved:
+        #Clearing for image processing
+        if not robot.is_park():
+            print "Moving robot to park to clear camera view..."
+            robot.move_park()        
+        assert_img_in_cover_pos(segment)    
+        hexiposi.moved = False           
+
 
 
 def wait_end_of_move():
@@ -88,12 +98,12 @@ def update_tool(tool=None, x_offset=0.0, y_offset=0.0, z_offset=0.0):
 
 
 def assertValidAddress(segment, puck, sample):
-    if type(segment) == str:
+    if is_string(segment):
         segment = ord(segment.upper()) - ord('A') +1
     if segment<=0 or segment >6:
-        raise Excepton ("Invalid segment")
+        raise Exception ("Invalid segment")
     if puck<=0 or puck >5:
-        raise Excepton ("Invalid puck")
+        raise Exception ("Invalid puck")
     if sample<=0 or sample >16:
-        raise Excepton ("Invalid sample")
+        raise Exception ("Invalid sample")
         

script/motion/unmount.py

@@ -6,39 +6,25 @@ def unmount(segment, puck, sample, force=False):
     #Initial checks
     assertValidAddress(segment, puck, sample)
     robot.assert_no_task()
+    robot.reset_motion()
     robot.state.assertReady()
     robot.assert_cleared()
-
-    if hexiposi.homed == False:
-        raise Exception ("Hexiposi is not homed")
+    #robot.assert_in_known_point()
+    hexiposi.assert_homed()
 
     #Enabling
     enable_motion()
 
     set_hexiposi(segment)
 
-    if not force:
-        #Clearing for image processing
-        robot.move_park()
-        assert_img_in_cover_pos(segment)
+    if not force:        
+        visual_check_hexiposi(segment)
 
-    location = robot.get_current_point()
+    #location = robot.get_current_point()
 
-    
-    try:
-        robot.get_gonio()
-    except:
-        #TODO: recover
-        raise
-
-    try:
-        robot.move_dewar_wait()        
-    except:
-        #TODO: recover
-        raise
-
-    try:
-        robot.put_dewar(segment, puck, sample)
-    except:
-        #robot.move_dewar()        
-        raise
+    if not robot.is_gonio():
+        robot.move_gonio()
+            
+    robot.get_gonio()
+    robot.move_dewar()        
+    robot.put_dewar(segment, puck, sample)

script/test/TestCmdSynchronization.py

@@ -8,7 +8,7 @@ enable_motion()
 get_context().setLogLevel(java.util.logging.Level.FINER)
 try:
     while True:
-    #robot.move_dewar_wait()
+    #robot.move_dewar()
     #robot.move_park()
 
         log("Moving dewar", False)
@@ -17,7 +17,7 @@ try:
         log("Waiting", False)
         ret = robot.wait_task_finished(TASK_WAIT_ROBOT_POLLING)                   
         log("Moving dewar finished  (" + str(ret) + ") - pos: " + get_pos_str(), False)        
-        robot.assert_dewar_wait()
+        robot.assert_dewar()
 
 
         log("Moving park", False)