def __init__(self):
self._adapter = Adapter(('0.0.0.0', 7878))
self._pose = ThreeDSample('pose')
self._adapter.add_data_item(self._pose)
avail = Event('avail')
self._adapter.add_data_item(avail)
avail.set_value('AVAILABLE')
def __init__(self):
# Initialize the ROS Bridge subscriber node
rospy.init_node('bridge_subscriber')
# Read configuration file and extract topics and types
self.config = bridge_library.obtain_dataMap()
self.msg_parameters = ['url', 'adapter_port']
self.url = self.config[self.msg_parameters[0]]
self.adapter_port = self.config[self.msg_parameters[1]]
# Setup MTConnect Adapter for robot status data items
self.adapter = Adapter((self.url, self.adapter_port))
self.di_dict = {
} # XML data item dictionary to store MTConnect Adapter Events
# Setup ROS topics as specified in .yaml file
self.topic_name_list = [] # List of topic names
self.subscribed_list = [] # List of subscribed topics
self.lib_manifests = [] # Stores loaded ROS library manifests
# Topic type and MTConnect message members from the module import
self.topic_type_list = {}
self.member_types = {}
self.member_names = {}
# The ROS message text retainer, used to map ROS values to MTConnect XML tag.text
self.msg_text = {}
# Create the data sets for the topic types, member names, and member types
self.setup_topic_data()
# Start the adapter
rospy.loginfo('Start the Robot Link adapter')
self.adapter.start()
# Create class lock
self.lock = thread.allocate_lock()
# Loop through requested topics and spawn ROS subscribers when topics are available
topic_list = self.topic_name_list
dwell = 10
while topic_list:
published_topics = dict(rospy.get_published_topics())
for topic_name in topic_list:
if topic_name in published_topics.keys():
# Create ROS Subscriber
idx = topic_list.index(topic_name)
del topic_list[idx]
self.topic_listener(
(topic_name, self.topic_type_list[topic_name],
self.member_names[topic_name],
self.msg_text[topic_name]))
else:
rospy.loginfo(
'ROS Topic %s not available, will try to subscribe in %d seconds'
% (topic_name, dwell))
time.sleep(dwell)
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License."""
import sys, os, time
path, file = os.path.split(__file__)
sys.path.append(os.path.realpath(path) + '/../src')
from data_item import Event, SimpleCondition, Sample
from mtconnect_adapter import Adapter
if __name__ == "__main__":
adapter = Adapter(('localhost', 7878))
e1 = Event('e1')
adapter.add_data_item(e1)
c1 = SimpleCondition('c1')
adapter.add_data_item(c1)
s1 = Sample('s1')
adapter.add_data_item(s1)
adapter.start()
while True:
adapter.begin_gather()
e1.set_value(1)
s1.set_value(200.1)
adapter.complete_gather()
time.sleep(1.0)
def create_server():
fname = os.tmpnam()
adapter = Adapter(fname, 10000, socket.AF_UNIX)
return (fname, adapter)
limitations under the License."""
import sys, os, time
path, file = os.path.split(__file__)
sys.path.append(os.path.realpath(path) + '/../src')
from data_item import Event, SimpleCondition, Sample, ThreeDSample
from mtconnect_adapter import Adapter
import roslib
roslib.load_manifest('turtlesim')
import rospy
import turtlesim.msg
adapter = Adapter(('0.0.0.0', 7878))
pose = ThreeDSample('pose')
adapter.add_data_item(pose)
def handle_turtle_pose(msg, turtlename):
adapter.begin_gather()
pose.set_value((msg.x, msg.y, 0.0))
adapter.complete_gather()
if __name__ == "__main__":
avail = Event('avail')
adapter.add_data_item(avail)
avail.set_value('AVAILABLE')
adapter.start()
def __init__(self, host, port):
self.host = host
self.port = port
self.adapter = Adapter((host, port))
self.auto_time = Sample('auto_time')
self.adapter.add_data_item(self.auto_time)
self.cut_time = Sample('cut_time')
self.adapter.add_data_item(self.cut_time)
self.total_time = Sample('total_time')
self.adapter.add_data_item(self.total_time)
self.Xabs = Sample('Xabs')
self.adapter.add_data_item(self.Xabs)
self.Yabs = Sample('Yabs')
self.adapter.add_data_item(self.Yabs)
self.Zabs = Sample('Zabs')
self.adapter.add_data_item(self.Zabs)
self.Aabs = Sample('Aabs')
self.adapter.add_data_item(self.Aabs)
self.Babs = Sample('Babs')
self.adapter.add_data_item(self.Babs)
self.Srpm = Sample('Srpm')
self.adapter.add_data_item(self.Srpm)
self.estop = Event('estop')
self.adapter.add_data_item(self.estop)
self.power = Event('power')
self.adapter.add_data_item(self.power)
self._exec = Event('exec')
self.adapter.add_data_item(self._exec)
self.line = Event('line')
self.adapter.add_data_item(self.line)
self.program = Event('program')
self.adapter.add_data_item(self.program)
self.Fovr = Event('Fovr')
self.adapter.add_data_item(self.Fovr)
self.Sovr = Event('Sovr')
self.adapter.add_data_item(self.Sovr)
self.Tool_number = Event('Tool_number')
self.adapter.add_data_item(self.Tool_number)
self.mode = Event('mode')
self.adapter.add_data_item(self.mode)
self.avail = Event('avail')
self.adapter.add_data_item(self.avail)
self.adapter.start()
self.adapter.begin_gather()
self.avail.set_value("AVAILABLE")
self.adapter.complete_gather()
self.adapter_stream()
def __init__(self):
# Initialize ROS generic client node
rospy.init_node('ActionClient')
# Setup MTConnect to ROS Conversion
self.config = bridge_library.obtain_dataMap()
self.msg_parameters = [
'url', 'url_port', 'machine_tool', 'xml_namespace', 'adapter_port',
'service'
]
self.url = self.config[self.msg_parameters[0]]
self.url_port = self.config[self.msg_parameters[1]]
self.mtool = self.config[self.msg_parameters[2]]
self.ns = dict(m=self.config[self.msg_parameters[3]])
self.port = self.config[self.msg_parameters[4]]
self.service = self.config[self.msg_parameters[5]]
# Check for url connectivity, dwell until system timeout
bridge_library.check_connectivity((1, self.url, self.url_port))
# Setup MTConnect Adapter for robot status data items
self.adapter = Adapter((self.url, self.port))
# Create empty lists for actions, message type handles, etc.
self.lib_manifests = []
self.type_handle = None
self.action_list = {}
self.action_goals = {}
self.package = None
self.xml_goal = None
self.di_dict = {
} # XML data item dictionary to store MTConnect Adapter Events
self.handshake = None
# Setup action client data per the config file
self.setup_topic_data()
# Add data items to the MTConnect Adapter - must be unique data items
bridge_library.add_event(
(self.adapter, self.action_list, self.di_dict, False))
# Start the adapter
rospy.loginfo('Start the Robot Link adapter')
self.adapter.start()
# Create robot Service Server thread for each machine tool action
self.action_service = []
for mt_action in self.action_goals.keys():
self.action_service.append(
ActionService(mt_action, self.adapter, self.di_dict,
self.service_handle, self.service))
# Establish XML connection, read in current XML
while True:
try:
self.conn = HTTPConnection(self.url, self.url_port)
response = bridge_library.xml_get_response(
(self.url, self.url_port, self.port, self.conn,
self.mtool + "/current"))
body = response.read()
break
except socket.error as e:
rospy.loginfo('HTTP connection error %s' % e)
time.sleep(10)
# Parse the XML and determine the current sequence and XML Event elements
seq, elements = bridge_library.xml_components(body, self.ns,
self.action_list)
# Start a streaming XML connection
response = bridge_library.xml_get_response(
(self.url, self.url_port, self.port, self.conn,
self.mtool + "/sample?interval=1000&count=1000&from=" + seq))
# Create class lock
self.lock = thread.allocate_lock()
# Create XML polling thread
lp = LongPull(response)
lp.long_pull(self.xml_callback) # Runs until user interrupts
def __init__(self):
# Initialize ROS generic client node
rospy.init_node('ActionServer')
# Setup MTConnect to ROS Conversion
self.config = bridge_library.obtain_dataMap()
self.msg_parameters = ['url', 'url_port', 'machine_tool', 'xml_namespace', 'adapter_port']
self.url = self.config[self.msg_parameters[0]]
self.url_port = self.config[self.msg_parameters[1]]
self.mtool = self.config[self.msg_parameters[2]]
self.ns = dict(m = self.config[self.msg_parameters[3]])
self.port = self.config[self.msg_parameters[4]]
# Check for url connectivity, dwell until system timeout
bridge_library.check_connectivity((1,self.url,self.url_port))
# Setup MTConnect Adapter for robot status data items
self.adapter = Adapter((self.url, self.port))
# Create empty lists for actions, message type handles, etc.
self.lib_manifests = []
self.type_handle = None
self.action_list = {}
self.capture_xml = False
self.di_dict = {} # XML data item dictionary to store MTConnect Adapter Events
# Create a dictionary of _results to return upon action success
self._resultDict = {}
# Create a dictionary of action servers
self._as = {}
# Create a dictionary of server names
self.server_name = {}
# Setup action client data per the config file
self.setup_topic_data()
# Add data items to the MTConnect Adapter - must be unique data items
bridge_library.add_event((self.adapter, self.action_list, self.di_dict, True))
# Start the adapter
rospy.loginfo('Start the Robot Link adapter')
self.adapter.start()
# Establish XML connection, read in current XML
while True:
try:
self.conn = HTTPConnection(self.url, self.url_port)
response = bridge_library.xml_get_response((self.url, self.url_port, self.port, self.conn, self.mtool + "/current"))
body = response.read()
break
except socket.error as e:
rospy.loginfo('HTTP connection error %s' % e)
time.sleep(10)
# Parse the XML and determine the current sequence and XML Event elements
seq, elements = bridge_library.xml_components(body, self.ns, self.action_list)
# Start a streaming XML connection
response = bridge_library.xml_get_response((self.url, self.url_port, self.port, self.conn, self.mtool + "/sample?interval=1000&count=1000&from=" + seq))
# Create queue for streaming XML
self.XML_queue = Queue()
# Create XML polling thread
lp = LongPull(response)
xml_thread = Thread(target = lp.long_pull, args = (self.xml_callback,))
xml_thread.daemon = True
xml_thread.start()
