[jccourtney]

I am having trouble simultaneously simulating two robots at the same time. I have two robots, "Robot A" and "Robot B" that each perform a large function. These functions reference user defined functions in two separate files, but they both work. 

The trouble I'm having is that I can get either robot to complete its function, but not both. What am I doing wrong here, and how do I need to modify the robolink commands to make this setup work? Can someone assist?



My python code is pasted below. I am not sure what I am doing differently than on the following example: 

https://robodk.com/doc/en/PythonAPI/exam...e-3-robots

Thanks!

Code:

# Type help("robolink") or help("robodk") for more information
# Press F5 to run the script
# Documentation: https://robodk.com/doc/en/RoboDK-API.html
# Reference:     https://robodk.com/doc/en/PythonAPI/index.html
# Note: It is not required to keep a copy of this file, your python script is saved with the station
from robolink import *    # RoboDK API
from robodk import *      # Robot toolbox
from M75_Pick_Place import *
from M75_Place_Clean import *
import threading
import time

def run_robot_a():
   # Gather required items from the station tree for Robot A
   rdk_a = Robolink()
   robot_a = rdk_a.Item('UR5e')

   rdk_a.ShowMessage("Robot A")
   #robot_a = rdk_a.Item('UR5e')
   a_home = rdk_a.Item('A_HOME') #Joint target
   a_pick_to_clean_0 = rdk_a.Item('A_PICK_TO_CLEAN0') #Joint target
   a_pick_to_clean_1 = rdk_a.Item('A_PICK_TO_CLEAN1') #Joint target
   a_pick_to_clean_2 = rdk_a.Item('A_PICK_TO_CLEAN2') #Joint target
   a_pick_to_clean_3 = rdk_a.Item('A_PICK_TO_CLEAN3') #Joint target

   bin_input_active = rdk_a.Item('Active Input Bin') #Reference frame of 'Active Bin'
   m75_tray = rdk_a.Item('M75 Input Tray') #Reference frame of 'M75 Tray'
   disk_3a = rdk_a.Item('Disk3A') #Disk3A Reference Frame
   disk_1a = rdk_a.Item('Disk1A') #Disk1A Reference Frame
   robot_a.setPoseFrame(bin_input_active)
   blade_count = 0


   #Set linear speed, acceleration, and rounding for Robot A
   robot_a.setSpeed(500)
   robot_a.setAcceleration(1200)
   robot_a.setRounding(20)

   #Start at safe home position
   robot_a.MoveJ(a_home)
   robot_a.MoveJ(a_pick_to_clean_0)

   #Cycle through each position
   while blade_count < 84:
       #Update location of active bin
       m75_set_active_bin_pos(rdk_a, robot_a, blade_count)
       #Pick
       robot_a.setSpeed(500)
       m75_pick_fwd(rdk_a, robot_a)
       #Grip part here
       m75_pick_rev(rdk_a, robot_a)
       robot_a.setSpeed(500)
       #Pause
       robot_a.Pause(0.5)

       #Move safely out of pick area
       robot_a.setRounding(20)
       robot_a.MoveJ(a_pick_to_clean_0)
       robot_a.MoveJ(a_pick_to_clean_1)
       robot_a.MoveJ(a_pick_to_clean_2)
       robot_a.MoveJ(a_pick_to_clean_3)

       #Clean Disk 3A
       robot_a.setPoseFrame(disk_3a)
       m75_clean_3a(rdk_a, robot_a)

       #Reset cleaning position
       robot_a.MoveJ(a_pick_to_clean_3)

       #Clean Disk 1A
       robot_a.setPoseFrame(disk_1a)
       m75_clean_1a(rdk_a, robot_a)

       #Move safely from clean area to pick area
       robot_a.setRounding(20)
       robot_a.MoveJ(a_pick_to_clean_3)
       robot_a.MoveJ(a_pick_to_clean_2)
       robot_a.MoveJ(a_pick_to_clean_1)
       robot_a.MoveJ(a_pick_to_clean_0)    

       robot_a.setPoseFrame(bin_input_active)
       
       #Place
       robot_a.setSpeed(500)
       m75_place_fwd(rdk_a, robot_a)
       #Release part here
       m75_place_rev(rdk_a, robot_a)
       robot_a.setSpeed(500)

       #Pause
       robot_a.Pause(0.5)

       #Increase blade count for next pick
       blade_count = blade_count + 1


   #Move Safely back to home position
   robot_a.MoveJ(a_pick_to_clean_0)    
   robot_a.MoveJ(a_home)



def run_robot_b():
   # Gather required items from the station tree for Robot B
   rdk_b = Robolink()
   robot_b = rdk_b.Item('UR5e2')  

   rdk_b.ShowMessage("Robot B")
   #robot_b = rdk_a.Item('UR5e2')
   bin_output_active = rdk_b.Item('Active Output Bin') #Reference frame of 'Active Bin'
   table_center = rdk_b.Item('Table Center')
   b_home = rdk_b.Item('B_HOME')
   b_home_to_clean = rdk_b.Item('B_HOME_TO_CLEAN')  
   b_place_to_clean_0 = rdk_b.Item('B_PLACE_TO_CLEAN0')
   b_place_to_clean_1 = rdk_b.Item('B_PLACE_TO_CLEAN1')
   b_place_to_clean_2 = rdk_b.Item('B_PLACE_TO_CLEAN2')
   b_place_to_clean_3 = rdk_b.Item('B_PLACE_TO_CLEAN3')    

   blade_count = 0

   #Set linear speed, acceleration, and rounding for Robot A
   robot_b.setSpeed(500)
   robot_b.setAcceleration(1200)
   robot_b.setRounding(20)


   #Start at safe home position
   robot_b.MoveJ(b_home)
   
   #Move from home position to clean position
   robot_b.MoveJ(b_home)
   robot_b.MoveJ(b_home_to_clean)    
   robot_b.MoveJ(b_place_to_clean_3)
   
   #Cycle through each position
   while blade_count < 84:


       #Swap
       #robot_b.setPoseFrame(table_center)        
       #b_m75_swap(rdk_b, robot_b)

       #robot_b.MoveJ(b_place_to_clean_1)
       #robot_b.MoveJ(b_place_to_clean_2)
       
       
       #Clean at Disk 3B
       robot_b.Pause(0.50)

       #Move from clean area to pick area
       robot_b.MoveJ(b_place_to_clean_3)
       robot_b.MoveJ(b_place_to_clean_2)
       robot_b.MoveJ(b_place_to_clean_1)
       robot_b.MoveJ(b_place_to_clean_0)        

       #Place
       robot_b.setPoseFrame(bin_output_active)
       #Update location of active bin
       b_m75_set_active_bin_pos(rdk_b, robot_b, blade_count)
   
       robot_b.setSpeed(500)
       b_m75_place_fwd(rdk_b, robot_b)
       
       #Release part here

       #Pause
       robot_b.Pause(0.25)

       b_m75_place_rev(rdk_b, robot_b)
       robot_b.setSpeed(500)


       #Move safely out of place area back to clean area
       robot_b.setRounding(20)
       robot_b.MoveJ(b_place_to_clean_0)
       robot_b.MoveJ(b_place_to_clean_1)
       robot_b.MoveJ(b_place_to_clean_2)      
       robot_b.MoveJ(b_place_to_clean_3)  

       #Increase blade count for next place
       blade_count = blade_count + 1


   #Move Safely back to home position  
   robot_b.MoveJ(b_home)
   


##--------------------------Max Width-----------------------------------------#
## The program starts here:

demask_station = Robolink()
#robot_a = demask_station.Item('UR5e')
#robot_b = demask_station.Item('UR5e2')

#demask_station.ShowMessage("Before Threads")

thread_a = threading.Thread(target = run_robot_a, args = ())
thread_b = threading.Thread(target = run_robot_b, args = ())

thread_a.start()
thread_b.start()



thread_a.join()
thread_b.join()

#demask_station.ShowMessage("After Threads")

[jccourtney]

I was able to solve this problem after a ton of debugging via two solutions of which I chose the 2nd option:

1. Adding a short sleep command after the first thread start call.

Code:

thread_a.start()
sleep(0.01)
thread_b.start()

2. Removing the last ShowMessage line of code. It appears this is a slower function. I was using it to debug before I realized I just could print to the console.

Code:

def run_robot_a():
  # Gather required items from the station tree for Robot A
  rdk_a = Robolink()
  robot_a = rdk_a.Item('UR5e')

  rdk_a.ShowMessage("Robot A")