ABBRobotEGM 1.0.1__tar.gz

abbrobotegm-1.0.1/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   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.

abbrobotegm-1.0.1/MANIFEST.in

@@ -0,0 +1,2 @@
+include LICENSE
+include README.md

abbrobotegm-1.0.1/PKG-INFO

@@ -0,0 +1,138 @@
+Metadata-Version: 2.2
+Name: ABBRobotEGM
+Version: 1.0.1
+Summary: A Python library for real-time control and data streaming of ABB robots using EGM protocol, enabling high-frequency (250Hz) communication through UDP for industrial automation applications.
+Home-page: https://github.com/FLo-ABB/ABB-EGM-Python
+Author: Florian LOBERT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: protobuf
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# ABBRobotEGM
+
+![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)
+
+`ABBRobotEGM` is a Python library for interfacing with ABB robots using Externally Guided Motion (EGM). This library provides real-time streaming communication with ABB robots at rates up to 250Hz using UDP.  It's based on the official ABB EGM [documentation](https://github.com/FLo-ABB/ABB-EGM-Python/blob/main/doc/3HAC073318%20AM%20Externally%20Guided%20Motion%20RW7-en.pdf) and examples, and it's designed to be easy to use and to integrate with other systems.
+
+## Prerequisites
+
+- Python 3.x
+- ABB RobotWare 7.X (should work with 6.X with few modifications)
+- ABB Robot with EGM option (3124-1 Externally Guided Motion)
+
+
+## Installation 🚀
+
+### Using pip 🐍
+
+To install the library using pip, run the following command:
+
+```bash
+pip install ABBRobotEGM
+```
+
+### Manual Installation 📦
+
+To use this library in your project, first download the repository and place the `ABBRobotEGM` folder in your project's directory. You can then import the `EGM` class from this library to use it in your project.
+
+## Simple Examples
+
+The repository includes several examples demonstrating different EGM functionalities. Inside each python example file, you can find the relative **RAPID** code that should be running on the robot controller.
+
+### Guidance Mode
+
+#### 1. Joint
+
+example_joint_guidance.py - Makes the first joint oscillate between -45° and +45°:
+
+#### 2. Cartesian
+example_pose_guidance.py - Makes the robot move in a circular pattern
+
+### Streaming Mode
+
+#### 1. Joint Streaming
+example_joint_stream.py - Streams robot joint positions :
+```python	
+from ABBRobotEGM import EGM
+
+def main() -> None:
+    """
+    Example showing how to stream the robot's position.
+    Be sure the robot is running before running this script.
+    """
+    with EGM() as egm:
+        while True:
+            success, state = egm.receive_from_robot()
+            if not success:
+                print("Failed to receive from robot")
+                break
+            print(f"{state.clock[1]}, {state.joint_angles[0]}, {state.joint_angles[1]}, {state.joint_angles[2]}, {state.joint_angles[3]}, {state.joint_angles[4]}, {state.joint_angles[5]}")
+
+
+if __name__ == "__main__":
+    main()
+
+```	
+
+
+#### 2. Cartesian Streaming
+example_pos_stream.py - Streams robot cartesian position
+```python	
+from ABBRobotEGM import EGM
+
+def main() -> None:
+    """
+    Example showing how to stream the robot's position.
+    Be sure the robot is running before running this script.
+    """
+    with EGM() as egm:
+        while True:
+            success, state = egm.receive_from_robot()
+            if not success:
+                print("Failed to receive from robot")
+                break
+            print(f"{state.clock[1]}, {state.cartesian.pos.x}, {state.cartesian.pos.y}, {state.cartesian.pos.z}")
+
+
+if __name__ == "__main__":
+    main()
+```
+
+### 3. Data Exchange
+example_table.py - Demonstrates exchanging data arrays with the robot
+
+## Complex Scenario
+Example of a more complex scenario where the robot is scanning a surface giving in real time its tool center point position and correlating with a sensor reading. Rspag and python code available in *"scenario scan"* folder.
+
+https://github.com/user-attachments/assets/03f151de-e098-4255-ac46-7dff42231071
+
+## Features 🚀
+
+- Real-time communication at up to 250Hz
+- Joint position control
+- Cartesian position control
+- Position streaming
+- Path corrections
+- RAPID data exchange
+- External axis support
+- Force measurement reading
+- Comprehensive robot state feedback
+
+
+## Contributing 🤝
+
+Contributions are welcome! Please feel free to submit pull requests.

abbrobotegm-1.0.1/README.md

@@ -0,0 +1,114 @@
+# ABBRobotEGM
+
+![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)
+
+`ABBRobotEGM` is a Python library for interfacing with ABB robots using Externally Guided Motion (EGM). This library provides real-time streaming communication with ABB robots at rates up to 250Hz using UDP.  It's based on the official ABB EGM [documentation](https://github.com/FLo-ABB/ABB-EGM-Python/blob/main/doc/3HAC073318%20AM%20Externally%20Guided%20Motion%20RW7-en.pdf) and examples, and it's designed to be easy to use and to integrate with other systems.
+
+## Prerequisites
+
+- Python 3.x
+- ABB RobotWare 7.X (should work with 6.X with few modifications)
+- ABB Robot with EGM option (3124-1 Externally Guided Motion)
+
+
+## Installation 🚀
+
+### Using pip 🐍
+
+To install the library using pip, run the following command:
+
+```bash
+pip install ABBRobotEGM
+```
+
+### Manual Installation 📦
+
+To use this library in your project, first download the repository and place the `ABBRobotEGM` folder in your project's directory. You can then import the `EGM` class from this library to use it in your project.
+
+## Simple Examples
+
+The repository includes several examples demonstrating different EGM functionalities. Inside each python example file, you can find the relative **RAPID** code that should be running on the robot controller.
+
+### Guidance Mode
+
+#### 1. Joint
+
+example_joint_guidance.py - Makes the first joint oscillate between -45° and +45°:
+
+#### 2. Cartesian
+example_pose_guidance.py - Makes the robot move in a circular pattern
+
+### Streaming Mode
+
+#### 1. Joint Streaming
+example_joint_stream.py - Streams robot joint positions :
+```python	
+from ABBRobotEGM import EGM
+
+def main() -> None:
+    """
+    Example showing how to stream the robot's position.
+    Be sure the robot is running before running this script.
+    """
+    with EGM() as egm:
+        while True:
+            success, state = egm.receive_from_robot()
+            if not success:
+                print("Failed to receive from robot")
+                break
+            print(f"{state.clock[1]}, {state.joint_angles[0]}, {state.joint_angles[1]}, {state.joint_angles[2]}, {state.joint_angles[3]}, {state.joint_angles[4]}, {state.joint_angles[5]}")
+
+
+if __name__ == "__main__":
+    main()
+
+```	
+
+
+#### 2. Cartesian Streaming
+example_pos_stream.py - Streams robot cartesian position
+```python	
+from ABBRobotEGM import EGM
+
+def main() -> None:
+    """
+    Example showing how to stream the robot's position.
+    Be sure the robot is running before running this script.
+    """
+    with EGM() as egm:
+        while True:
+            success, state = egm.receive_from_robot()
+            if not success:
+                print("Failed to receive from robot")
+                break
+            print(f"{state.clock[1]}, {state.cartesian.pos.x}, {state.cartesian.pos.y}, {state.cartesian.pos.z}")
+
+
+if __name__ == "__main__":
+    main()
+```
+
+### 3. Data Exchange
+example_table.py - Demonstrates exchanging data arrays with the robot
+
+## Complex Scenario
+Example of a more complex scenario where the robot is scanning a surface giving in real time its tool center point position and correlating with a sensor reading. Rspag and python code available in *"scenario scan"* folder.
+
+https://github.com/user-attachments/assets/03f151de-e098-4255-ac46-7dff42231071
+
+## Features 🚀
+
+- Real-time communication at up to 250Hz
+- Joint position control
+- Cartesian position control
+- Position streaming
+- Path corrections
+- RAPID data exchange
+- External axis support
+- Force measurement reading
+- Comprehensive robot state feedback
+
+
+## Contributing 🤝
+
+Contributions are welcome! Please feel free to submit pull requests.

abbrobotegm-1.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

abbrobotegm-1.0.1/setup.py

@@ -0,0 +1,24 @@
+from setuptools import setup, find_packages
+
+setup(
+    name='ABBRobotEGM',
+    version='v1.0.1',
+    description='A Python library for real-time control and data streaming of ABB robots using EGM protocol, enabling high-frequency (250Hz) communication through UDP for industrial automation applications.',
+    long_description=open('README.md', encoding='utf-8').read(),
+    long_description_content_type='text/markdown',
+    author='Florian LOBERT',
+    url='https://github.com/FLo-ABB/ABB-EGM-Python',
+    packages=find_packages(where='src'),
+    package_dir={'': 'src'},
+    classifiers=[
+        'Programming Language :: Python :: 3',
+        'License :: OSI Approved :: Apache Software License',  # Fixed classifier
+        'Operating System :: OS Independent',
+        'Intended Audience :: Developers',
+    ],
+    python_requires='>=3.6',  # Specify minimum Python version
+    install_requires=[
+        'numpy',
+        'protobuf',
+    ],
+)

abbrobotegm-1.0.1/src/ABBRobotEGM/__init__.py

@@ -0,0 +1 @@
+from .egm import EGM

abbrobotegm-1.0.1/src/ABBRobotEGM/_egm_protobuf/egm_pb2.py

@@ -0,0 +1,78 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: egm.proto
+# Protobuf Python Version: 4.25.6
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\tegm.proto\x12\x07\x61\x62\x62.egm\"\xeb\x01\n\tEgmHeader\x12\r\n\x05seqno\x18\x01 \x01(\r\x12\n\n\x02tm\x18\x02 \x01(\r\x12@\n\x05mtype\x18\x03 \x01(\x0e\x32\x1e.abb.egm.EgmHeader.MessageType:\x11MSGTYPE_UNDEFINED\"\x80\x01\n\x0bMessageType\x12\x15\n\x11MSGTYPE_UNDEFINED\x10\x00\x12\x13\n\x0fMSGTYPE_COMMAND\x10\x01\x12\x10\n\x0cMSGTYPE_DATA\x10\x02\x12\x16\n\x12MSGTYPE_CORRECTION\x10\x03\x12\x1b\n\x17MSGTYPE_PATH_CORRECTION\x10\x04\"/\n\x0c\x45gmCartesian\x12\t\n\x01x\x18\x01 \x02(\x01\x12\t\n\x01y\x18\x02 \x02(\x01\x12\t\n\x01z\x18\x03 \x02(\x01\"?\n\rEgmQuaternion\x12\n\n\x02u0\x18\x01 \x02(\x01\x12\n\n\x02u1\x18\x02 \x02(\x01\x12\n\n\x02u2\x18\x03 \x02(\x01\x12\n\n\x02u3\x18\x04 \x02(\x01\"+\n\x08\x45gmEuler\x12\t\n\x01x\x18\x01 \x02(\x01\x12\t\n\x01y\x18\x02 \x02(\x01\x12\t\n\x01z\x18\x03 \x02(\x01\"%\n\x08\x45gmClock\x12\x0b\n\x03sec\x18\x01 \x02(\x04\x12\x0c\n\x04usec\x18\x02 \x02(\x04\")\n\x0c\x45gmTimestamp\x12\x0b\n\x03sec\x18\x01 \x01(\x04\x12\x0c\n\x04nsec\x18\x02 \x01(\x04\"w\n\x07\x45gmPose\x12\"\n\x03pos\x18\x01 \x01(\x0b\x32\x15.abb.egm.EgmCartesian\x12&\n\x06orient\x18\x02 \x01(\x0b\x32\x16.abb.egm.EgmQuaternion\x12 \n\x05\x65uler\x18\x03 \x01(\x0b\x32\x11.abb.egm.EgmEuler\"\"\n\x11\x45gmCartesianSpeed\x12\r\n\x05value\x18\x01 \x03(\x01\"\x1b\n\tEgmJoints\x12\x0e\n\x06joints\x18\x01 \x03(\x01\"#\n\x11\x45gmExternalJoints\x12\x0e\n\x06joints\x18\x01 \x03(\x01\"\xcc\x01\n\nEgmPlanned\x12\"\n\x06joints\x18\x01 \x01(\x0b\x32\x12.abb.egm.EgmJoints\x12#\n\tcartesian\x18\x02 \x01(\x0b\x32\x10.abb.egm.EgmPose\x12*\n\x0e\x65xternalJoints\x18\x03 \x01(\x0b\x32\x12.abb.egm.EgmJoints\x12\x1f\n\x04time\x18\x04 \x01(\x0b\x32\x11.abb.egm.EgmClock\x12(\n\ttimeStamp\x18\x05 \x01(\x0b\x32\x15.abb.egm.EgmTimestamp\"\x8d\x01\n\x0b\x45gmSpeedRef\x12\"\n\x06joints\x18\x01 \x01(\x0b\x32\x12.abb.egm.EgmJoints\x12.\n\ncartesians\x18\x02 \x01(\x0b\x32\x1a.abb.egm.EgmCartesianSpeed\x12*\n\x0e\x65xternalJoints\x18\x03 \x01(\x0b\x32\x12.abb.egm.EgmJoints\">\n\x0b\x45gmPathCorr\x12\"\n\x03pos\x18\x01 \x02(\x0b\x32\x15.abb.egm.EgmCartesian\x12\x0b\n\x03\x61ge\x18\x02 \x02(\r\"\xcd\x01\n\x0b\x45gmFeedBack\x12\"\n\x06joints\x18\x01 \x01(\x0b\x32\x12.abb.egm.EgmJoints\x12#\n\tcartesian\x18\x02 \x01(\x0b\x32\x10.abb.egm.EgmPose\x12*\n\x0e\x65xternalJoints\x18\x03 \x01(\x0b\x32\x12.abb.egm.EgmJoints\x12\x1f\n\x04time\x18\x04 \x01(\x0b\x32\x11.abb.egm.EgmClock\x12(\n\ttimeStamp\x18\x05 \x01(\x0b\x32\x15.abb.egm.EgmTimestamp\"\x8c\x01\n\rEgmMotorState\x12\x34\n\x05state\x18\x01 \x02(\x0e\x32%.abb.egm.EgmMotorState.MotorStateType\"E\n\x0eMotorStateType\x12\x14\n\x10MOTORS_UNDEFINED\x10\x00\x12\r\n\tMOTORS_ON\x10\x01\x12\x0e\n\nMOTORS_OFF\x10\x02\"\xa2\x01\n\x0b\x45gmMCIState\x12?\n\x05state\x18\x01 \x02(\x0e\x32!.abb.egm.EgmMCIState.MCIStateType:\rMCI_UNDEFINED\"R\n\x0cMCIStateType\x12\x11\n\rMCI_UNDEFINED\x10\x00\x12\r\n\tMCI_ERROR\x10\x01\x12\x0f\n\x0bMCI_STOPPED\x10\x02\x12\x0f\n\x0bMCI_RUNNING\x10\x03\"\xc3\x01\n\x15\x45gmRapidCtrlExecState\x12U\n\x05state\x18\x01 \x02(\x0e\x32\x35.abb.egm.EgmRapidCtrlExecState.RapidCtrlExecStateType:\x0fRAPID_UNDEFINED\"S\n\x16RapidCtrlExecStateType\x12\x13\n\x0fRAPID_UNDEFINED\x10\x00\x12\x11\n\rRAPID_STOPPED\x10\x01\x12\x11\n\rRAPID_RUNNING\x10\x02\"!\n\x0e\x45gmTestSignals\x12\x0f\n\x07signals\x18\x01 \x03(\x01\"3\n\x10\x45gmMeasuredForce\x12\x10\n\x08\x66\x63\x41\x63tive\x18\x01 \x01(\x08\x12\r\n\x05\x66orce\x18\x02 \x03(\x01\"C\n\x10\x45gmCollisionInfo\x12\x19\n\x11\x63ollsionTriggered\x18\x01 \x01(\x08\x12\x14\n\x0c\x63ollDetQuota\x18\x02 \x03(\x01\",\n\x0c\x45gmRAPIDdata\x12\x0e\n\x06\x64igVal\x18\x01 \x01(\x08\x12\x0c\n\x04\x64num\x18\x02 \x03(\x01\"\xb7\x04\n\x08\x45gmRobot\x12\"\n\x06header\x18\x01 \x01(\x0b\x32\x12.abb.egm.EgmHeader\x12&\n\x08\x66\x65\x65\x64\x42\x61\x63k\x18\x02 \x01(\x0b\x32\x14.abb.egm.EgmFeedBack\x12$\n\x07planned\x18\x03 \x01(\x0b\x32\x13.abb.egm.EgmPlanned\x12*\n\nmotorState\x18\x04 \x01(\x0b\x32\x16.abb.egm.EgmMotorState\x12&\n\x08mciState\x18\x05 \x01(\x0b\x32\x14.abb.egm.EgmMCIState\x12\x19\n\x11mciConvergenceMet\x18\x06 \x01(\x08\x12,\n\x0btestSignals\x18\x07 \x01(\x0b\x32\x17.abb.egm.EgmTestSignals\x12\x36\n\x0erapidExecState\x18\x08 \x01(\x0b\x32\x1e.abb.egm.EgmRapidCtrlExecState\x12\x30\n\rmeasuredForce\x18\t \x01(\x0b\x32\x19.abb.egm.EgmMeasuredForce\x12\x17\n\x0futilizationRate\x18\n \x01(\x01\x12\x11\n\tmoveIndex\x18\x0b \x01(\r\x12\x30\n\rCollisionInfo\x18\x0c \x01(\x0b\x32\x19.abb.egm.EgmCollisionInfo\x12-\n\x0eRAPIDfromRobot\x18\r \x01(\x0b\x32\x15.abb.egm.EgmRAPIDdata\x12%\n\ttorqueRef\x18\x0e \x01(\x0b\x32\x12.abb.egm.EgmJoints\"\xaa\x01\n\tEgmSensor\x12\"\n\x06header\x18\x01 \x01(\x0b\x32\x12.abb.egm.EgmHeader\x12$\n\x07planned\x18\x02 \x01(\x0b\x32\x13.abb.egm.EgmPlanned\x12&\n\x08speedRef\x18\x03 \x01(\x0b\x32\x14.abb.egm.EgmSpeedRef\x12+\n\x0cRAPIDtoRobot\x18\x04 \x01(\x0b\x32\x15.abb.egm.EgmRAPIDdata\"_\n\x11\x45gmSensorPathCorr\x12\"\n\x06header\x18\x01 \x01(\x0b\x32\x12.abb.egm.EgmHeader\x12&\n\x08pathCorr\x18\x02 \x01(\x0b\x32\x14.abb.egm.EgmPathCorr')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'egm_pb2', _globals)
+if _descriptor._USE_C_DESCRIPTORS is False:
+    DESCRIPTOR._options = None
+    _globals['_EGMHEADER']._serialized_start = 23
+    _globals['_EGMHEADER']._serialized_end = 258
+    _globals['_EGMHEADER_MESSAGETYPE']._serialized_start = 130
+    _globals['_EGMHEADER_MESSAGETYPE']._serialized_end = 258
+    _globals['_EGMCARTESIAN']._serialized_start = 260
+    _globals['_EGMCARTESIAN']._serialized_end = 307
+    _globals['_EGMQUATERNION']._serialized_start = 309
+    _globals['_EGMQUATERNION']._serialized_end = 372
+    _globals['_EGMEULER']._serialized_start = 374
+    _globals['_EGMEULER']._serialized_end = 417
+    _globals['_EGMCLOCK']._serialized_start = 419
+    _globals['_EGMCLOCK']._serialized_end = 456
+    _globals['_EGMTIMESTAMP']._serialized_start = 458
+    _globals['_EGMTIMESTAMP']._serialized_end = 499
+    _globals['_EGMPOSE']._serialized_start = 501
+    _globals['_EGMPOSE']._serialized_end = 620
+    _globals['_EGMCARTESIANSPEED']._serialized_start = 622
+    _globals['_EGMCARTESIANSPEED']._serialized_end = 656
+    _globals['_EGMJOINTS']._serialized_start = 658
+    _globals['_EGMJOINTS']._serialized_end = 685
+    _globals['_EGMEXTERNALJOINTS']._serialized_start = 687
+    _globals['_EGMEXTERNALJOINTS']._serialized_end = 722
+    _globals['_EGMPLANNED']._serialized_start = 725
+    _globals['_EGMPLANNED']._serialized_end = 929
+    _globals['_EGMSPEEDREF']._serialized_start = 932
+    _globals['_EGMSPEEDREF']._serialized_end = 1073
+    _globals['_EGMPATHCORR']._serialized_start = 1075
+    _globals['_EGMPATHCORR']._serialized_end = 1137
+    _globals['_EGMFEEDBACK']._serialized_start = 1140
+    _globals['_EGMFEEDBACK']._serialized_end = 1345
+    _globals['_EGMMOTORSTATE']._serialized_start = 1348
+    _globals['_EGMMOTORSTATE']._serialized_end = 1488
+    _globals['_EGMMOTORSTATE_MOTORSTATETYPE']._serialized_start = 1419
+    _globals['_EGMMOTORSTATE_MOTORSTATETYPE']._serialized_end = 1488
+    _globals['_EGMMCISTATE']._serialized_start = 1491
+    _globals['_EGMMCISTATE']._serialized_end = 1653
+    _globals['_EGMMCISTATE_MCISTATETYPE']._serialized_start = 1571
+    _globals['_EGMMCISTATE_MCISTATETYPE']._serialized_end = 1653
+    _globals['_EGMRAPIDCTRLEXECSTATE']._serialized_start = 1656
+    _globals['_EGMRAPIDCTRLEXECSTATE']._serialized_end = 1851
+    _globals['_EGMRAPIDCTRLEXECSTATE_RAPIDCTRLEXECSTATETYPE']._serialized_start = 1768
+    _globals['_EGMRAPIDCTRLEXECSTATE_RAPIDCTRLEXECSTATETYPE']._serialized_end = 1851
+    _globals['_EGMTESTSIGNALS']._serialized_start = 1853
+    _globals['_EGMTESTSIGNALS']._serialized_end = 1886
+    _globals['_EGMMEASUREDFORCE']._serialized_start = 1888
+    _globals['_EGMMEASUREDFORCE']._serialized_end = 1939
+    _globals['_EGMCOLLISIONINFO']._serialized_start = 1941
+    _globals['_EGMCOLLISIONINFO']._serialized_end = 2008
+    _globals['_EGMRAPIDDATA']._serialized_start = 2010
+    _globals['_EGMRAPIDDATA']._serialized_end = 2054
+    _globals['_EGMROBOT']._serialized_start = 2057
+    _globals['_EGMROBOT']._serialized_end = 2624
+    _globals['_EGMSENSOR']._serialized_start = 2627
+    _globals['_EGMSENSOR']._serialized_end = 2797
+    _globals['_EGMSENSORPATHCORR']._serialized_start = 2799
+    _globals['_EGMSENSORPATHCORR']._serialized_end = 2894
+# @@protoc_insertion_point(module_scope)

abbrobotegm-1.0.1/src/ABBRobotEGM/abb_data.py

@@ -0,0 +1,64 @@
+from typing import NamedTuple
+
+
+class Orientation(NamedTuple):
+    """
+    A class used to represent an Orientation in 3D space using quaternions.
+
+    Attributes
+    ----------
+    u0 : float
+        The scalar part of the quaternion.
+    u1 : float
+        The first component of the vector part of the quaternion.
+    u2 : float
+        The second component of the vector part of the quaternion.
+    u3 : float
+        The third component of the vector part of the quaternion.
+    """
+    u0: float
+    u1: float
+    u2: float
+    u3: float
+
+
+class Euler(NamedTuple):
+    """
+    A class to represent Euler angles.
+
+    Attributes:
+        rx (float): Rotation around the x-axis in radians.
+        ry (float): Rotation around the y-axis in radians.
+        rz (float): Rotation around the z-axis in radians.
+    """
+    rx: float
+    ry: float
+    rz: float
+
+
+class Pos(NamedTuple):
+    """
+    Pose is a NamedTuple that represents a pose in 3D space.
+
+    Attributes:
+        x (float): The x coordinate.
+        y (float): The y coordinate.
+        z (float): The z coordinate
+    """
+    x: float
+    y: float
+    z: float
+
+
+class Pose(NamedTuple):
+    """
+    A class to represent a 3D pose with x, y, and z coordinates.
+
+    Attributes:
+        pos (Position): The position component of the pose.
+        orient (Orientation): The orientation component of the pose.
+        euler (Euler): The Euler angles representing the orientation.
+    """
+    pos: Pos
+    orient: Orientation
+    euler: Euler

abbrobotegm-1.0.1/src/ABBRobotEGM/egm.py

@@ -0,0 +1,538 @@
+# Copyright 2022 Wason Technology LLC, Rensselaer Polytechnic Institute
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# 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 socket
+import select
+import numpy as np
+import errno
+from typing import Tuple, NamedTuple, Any, Optional
+from ABBRobotEGM._egm_protobuf import egm_pb2
+from .abb_data import Pos, Orientation, Euler, Pose
+
+# Constants
+DEFAULT_PORT = 6510
+BUFFER_SIZE = 65536
+TIMEOUT = 0.5
+
+
+class EGMHeader(NamedTuple):
+    """Represents EGM message header"""
+    seqno: int
+    tm: int
+    mtype: str
+
+
+class EGMTimeStamp(NamedTuple):
+    """Represents PTP/IEEE-1588 timestamp."""
+    seconds: int
+    nanoseconds: int
+
+
+class EGMClock(NamedTuple):
+    """Represents Unix timestamp."""
+    seconds: int
+    microseconds: int
+
+
+class EGMRobotState(NamedTuple):
+    """Represents the state of the robot as received from EGM feedback."""
+    # Header information
+    header: EGMHeader
+
+    # Feedback state
+    joint_angles: np.array
+    cartesian: Optional[Pose]
+    external_axes: np.array
+    clock: Optional[Tuple[int, int]]       # EgmClock (seconds, microseconds)
+    timestamp: Optional[Tuple[int, int]]   # EgmTimestamp (seconds, nanoseconds)
+
+    # Planned state
+    joint_angles_planned: np.array
+    cartesian_planned: Optional[Pose]
+    external_axes_planned: np.array
+    planned_clock: Optional[Tuple[int, int]]
+    planned_timestamp: Optional[Tuple[int, int]]
+
+    # Motor and execution state
+    motors_on: bool
+    mci_state: str
+    mci_convergence_met: bool
+    rapid_running: bool
+
+    # Forces and motion
+    measured_force: np.array
+    utilization_rate: float
+    move_index: int
+
+    # Collision and diagnostics
+    collision_info: Any
+    test_signals: np.array
+
+    # RAPID interface
+    rapid_from_robot: np.array
+
+    # Additional data
+    torque_ref: np.array
+    robot_message: Any  # Raw message for debugging
+
+
+class EGM:
+    """
+    ABB EGM (Externally Guided Motion) client. EGM provides a real-time streaming connection to the robot using
+    UDP, typically at a rate of 250 Hz. The robot controller initiates the connection. The IP address and port of the
+    client must be configured on the robot controller side. The EGM client will send commands to the port it receives
+    packets from.
+
+    :param port: The port to receive UDP packets. Defaults to 6510
+    """
+
+    def __init__(self, port: int = DEFAULT_PORT):
+        self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        self.socket.bind(('', port))
+        self.send_sequence_number = 0
+        self.egm_addr = None
+        self.count = 0
+
+    def __enter__(self):
+        """Enter the context manager protocol."""
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Exit the context manager protocol."""
+        self.close()
+
+    def receive_from_robot(self, timeout: float = TIMEOUT) -> Tuple[bool, Optional[EGMRobotState]]:
+        """
+        Receive feedback from the robot. Specify an optional timeout. Returns a tuple with success and the current
+        robot state.
+
+        :param timeout: Timeout in seconds. May be zero to immediately return if there is no new data.
+        :return: Success and robot state as a tuple
+        """
+        try:
+            res = select.select([self.socket], [], [self.socket], timeout)
+        except select.error as err:
+            if err.args[0] == errno.EINTR:
+                return False, None
+            raise
+
+        if not res[0] and not res[2]:
+            return False, None
+
+        try:
+            buf, addr = self.socket.recvfrom(BUFFER_SIZE)
+        except socket.error:
+            self.egm_addr = None
+            return False, None
+
+        self.egm_addr = addr
+        robot_message = egm_pb2.EgmRobot()
+        robot_message.ParseFromString(buf)
+
+        state = self._parse_robot_message(robot_message)
+        return True, state
+
+    def _parse_robot_message(self, robot_message: Any) -> EGMRobotState:
+        """Parse the robot message and return the robot state."""
+        # Get header information
+        header = EGMHeader(
+            seqno=robot_message.header.seqno if robot_message.HasField('header') else 0,
+            tm=robot_message.header.tm if robot_message.HasField('header') else 0,
+            mtype=robot_message.header.mtype if robot_message.HasField('header') else "UNDEFINED"
+        )
+
+        # Get feedback data
+        joint_angles = self._get_joint_angles(robot_message)
+        cartesian = self._get_cartesian(robot_message)
+        external_axes = self._get_external_axes(robot_message)
+        clock, timestamp = self._get_timestamps(robot_message)
+
+        # Get planned data
+        joint_angles_planned = self._get_joint_angles_planned(robot_message)
+        cartesian_planned = self._get_cartesian_planned(robot_message)
+        external_axes_planned = self._get_external_axes_planned(robot_message)
+        planned_clock, planned_timestamp = self._get_planned_timestamps(robot_message)
+
+        # Get motor and execution state
+        motors_on = self._get_motors_on(robot_message)
+        mci_state = self._get_mci_state(robot_message)
+        mci_convergence_met = self._get_mci_convergence_met(robot_message)
+        rapid_running = self._get_rapid_running(robot_message)
+
+        # Get forces and motion data
+        measured_force = self._get_measured_force(robot_message)
+        utilization_rate = self._get_utilization_rate(robot_message)
+        move_index = self._get_move_index(robot_message)
+
+        # Get collision and diagnostics
+        collision_info = self._get_collision_info(robot_message)
+        test_signals = self._get_test_signals(robot_message)
+
+        # Get RAPID and torque data
+        rapid_from_robot = self._get_rapid_from_robot(robot_message)
+        torque_ref = self._get_torque_ref(robot_message)
+
+        return EGMRobotState(
+            header=header,
+            joint_angles=joint_angles,
+            cartesian=cartesian,
+            external_axes=external_axes,
+            clock=clock,
+            timestamp=timestamp,
+            joint_angles_planned=joint_angles_planned,
+            cartesian_planned=cartesian_planned,
+            external_axes_planned=external_axes_planned,
+            planned_clock=planned_clock,
+            planned_timestamp=planned_timestamp,
+            motors_on=motors_on,
+            mci_state=mci_state,
+            mci_convergence_met=mci_convergence_met,
+            rapid_running=rapid_running,
+            measured_force=measured_force,
+            utilization_rate=utilization_rate,
+            move_index=move_index,
+            collision_info=collision_info,
+            test_signals=test_signals,
+            rapid_from_robot=rapid_from_robot,
+            torque_ref=torque_ref,
+            robot_message=robot_message
+        )
+
+    def _get_joint_angles(self, robot_message: Any) -> np.array:
+        if robot_message.HasField('feedBack'):
+            return np.array(list(robot_message.feedBack.joints.joints))
+        return np.array([])
+
+    def _get_rapid_running(self, robot_message: Any) -> bool:
+        if robot_message.HasField('rapidExecState'):
+            return robot_message.rapidExecState.state == robot_message.rapidExecState.RAPID_RUNNING
+        return False
+
+    def _get_motors_on(self, robot_message: Any) -> bool:
+        if robot_message.HasField('motorState'):
+            return robot_message.motorState.state == robot_message.motorState.MOTORS_ON
+        return False
+
+    def _get_cartesian(self, robot_message: Any) -> Optional[Pose]:
+        if robot_message.HasField('feedBack') and robot_message.feedBack.HasField('cartesian'):
+            cart_p = robot_message.feedBack.cartesian.pos
+            cart_q = robot_message.feedBack.cartesian.orient
+            return Pose(
+                pos=Pos(cart_p.x, cart_p.y, cart_p.z),
+                orient=Orientation(cart_q.u0, cart_q.u1, cart_q.u2, cart_q.u3),
+                euler=Euler(0, 0, 0)  # Assuming Euler angles are not provided in the message
+            )
+        return None
+
+    def _get_external_axes(self, robot_message: Any) -> np.array:
+        if robot_message.HasField('feedBack') and robot_message.feedBack.HasField('externalJoints'):
+            return np.array(list(robot_message.feedBack.externalJoints.joints))
+        return np.array([])
+
+    def _get_external_axes_planned(self, robot_message: Any) -> np.array:
+        if robot_message.HasField('planned') and robot_message.planned.HasField('externalJoints'):
+            return np.array(list(robot_message.planned.externalJoints.joints))
+        return np.array([])
+
+    def _get_joint_angles_planned(self, robot_message: Any) -> np.array:
+        if robot_message.HasField('planned') and robot_message.planned.HasField('joints'):
+            return np.array(list(robot_message.planned.joints.joints))
+        return np.array([])
+
+    def _get_cartesian_planned(self, robot_message: Any) -> Optional[Pose]:
+        if robot_message.HasField('planned') and robot_message.planned.HasField('cartesian'):
+            cart_p = robot_message.planned.cartesian.pos
+            cart_q = robot_message.planned.cartesian.orient
+            return Pose(
+                pos=Pos(cart_p.x, cart_p.y, cart_p.z),
+                orient=Orientation(cart_q.u0, cart_q.u1, cart_q.u2, cart_q.u3),
+                euler=Euler(0, 0, 0)  # Assuming Euler angles are not provided in the message
+            )
+        return None
+
+    def _get_measured_force(self, robot_message: Any) -> np.array:
+        if robot_message.HasField('measuredForce'):
+            force_active = robot_message.measuredForce.fcActive if robot_message.measuredForce.HasField('fcActive') else True
+            if force_active:
+                return np.array(list(robot_message.measuredForce.force))
+        return np.array([])
+
+    def _get_move_index(self, robot_message: Any) -> Optional[int]:
+        if robot_message.HasField('moveIndex'):
+            return robot_message.moveIndex
+        return None
+
+    def _get_rapid_from_robot(self, robot_message: Any) -> np.array:
+        if robot_message.HasField('RAPIDfromRobot'):
+            return np.array(list(robot_message.RAPIDfromRobot.dnum))
+        return np.array([])
+
+    def _get_mci_state(self, robot_message: Any) -> Optional[str]:
+        if robot_message.HasField('mciState'):
+            return robot_message.mciState.state
+        return None
+
+    def _get_mci_convergence_met(self, robot_message: Any) -> Optional[bool]:
+        if robot_message.HasField('mciConvergenceMet'):
+            return robot_message.mciConvergenceMet
+        return None
+
+    def _get_test_signals(self, robot_message: Any) -> np.array:
+        if robot_message.HasField('testSignals'):
+            return np.array(list(robot_message.testSignals.signals))
+        return np.array([])
+
+    def _get_utilization_rate(self, robot_message: Any) -> Optional[float]:
+        if robot_message.HasField('utilizationRate'):
+            return robot_message.utilizationRate
+        return None
+
+    def _get_collision_info(self, robot_message: Any) -> Optional[Any]:
+        if robot_message.HasField('CollisionInfo'):
+            return robot_message.CollisionInfo
+        return None
+
+    def debug_print_robot_message(self, robot_message: Any):
+        """
+        Print the robot message for debugging purposes.
+
+        :param robot_message: The robot message to print
+        """
+        print(robot_message)
+
+    def send_to_robot(self, joint_angles: Optional[np.array] = None,
+                      cartesian: Optional[Tuple[np.ndarray, np.ndarray]] = None,
+                      speed_ref: np.array = None, external_joints: np.array = None,
+                      external_joints_speed: np.array = None, rapid_to_robot: np.array = None, digital_signal_to_robot: bool = None) -> bool:
+        """
+        Send a command to robot. Returns False if no data has been received from the robot yet.
+        Either joint_angles or cartesian must be provided.
+
+        :param joint_angles: Joint angle command in degrees
+        :param cartesian: Tuple of (position, orientation) where:
+                        - position is [x,y,z] in millimeters
+                        - orientation is quaternion [w,x,y,z]
+        :param speed_ref: Speed reference for the joints
+        :param external_joints: External joints positions
+        :param external_joints_speed: External joints speed reference
+        :param rapid_to_robot: RAPID data to send to robot
+        :return: True if successful, False if no data received from robot yet
+        """
+        if not self.egm_addr:
+            return False
+
+        # if joint_angles is None and cartesian is None:
+        #     raise ValueError("Either joint_angles or cartesian must be provided")
+
+        self.send_sequence_number += 1
+
+        if cartesian is not None:
+            # If cartesian is provided, use cartesian control
+            pos, orient = cartesian
+            sensor_message = self._create_sensor_message_cart(
+                pos, orient, speed_ref, external_joints, external_joints_speed, rapid_to_robot, digital_signal_to_robot
+            )
+        else:
+            # Use joint control
+            sensor_message = self._create_sensor_message(
+                joint_angles, speed_ref, external_joints, external_joints_speed, rapid_to_robot, digital_signal_to_robot
+            )
+
+        return self._send_message(sensor_message)
+
+    def _create_sensor_message(self, joint_angles: np.array, speed_ref: np.array, external_joints: np.array,
+                               external_joints_speed: np.array, rapid_to_robot: np.array, digital_signal_to_robot: bool) -> Any:
+        """Create the sensor message to be sent to the robot."""
+        sensor_message = egm_pb2.EgmSensor()
+        header = sensor_message.header
+        header.mtype = egm_pb2.EgmHeader.MessageType.Value('MSGTYPE_CORRECTION')
+        header.seqno = self.send_sequence_number
+        self.send_sequence_number += 1
+
+        planned = sensor_message.planned
+        speed_ref_message = sensor_message.speedRef
+
+        if joint_angles is not None:
+            joint_angles = self._flatten_and_convert_to_list(joint_angles)
+            planned.joints.joints.extend(joint_angles)
+
+        if speed_ref is not None:
+            speed_ref = self._flatten_and_convert_to_list(speed_ref)
+            speed_ref_message.joints.joints.extend(speed_ref)
+
+        if external_joints is not None:
+            external_joints = self._flatten_and_convert_to_list(external_joints)
+            planned.externalJoints.joints.extend(external_joints)
+
+        if external_joints_speed is not None:
+            external_joints_speed = self._flatten_and_convert_to_list(external_joints_speed)
+            speed_ref_message.externalJoints.joints.extend(external_joints_speed)
+
+        if rapid_to_robot is not None:
+            rapid_to_robot = self._flatten_and_convert_to_list(rapid_to_robot)
+            sensor_message.RAPIDtoRobot.dnum.extend(rapid_to_robot)
+
+        if digital_signal_to_robot is not None:
+            sensor_message.RAPIDtoRobot.digVal = digital_signal_to_robot
+
+        return sensor_message
+
+    def _flatten_and_convert_to_list(self, array: np.array) -> list:
+        """Flatten the array and convert it to a list, ensuring homogeneous shape."""
+        try:
+            array = np.asarray(array, dtype=np.float64).flatten()
+        except ValueError:
+            raise ValueError("Input array has an inhomogeneous shape or contains non-numeric elements.")
+        return array.tolist()
+
+    def _send_message(self, message: Any) -> bool:
+        """Send the serialized message to the robot."""
+        buf = message.SerializeToString()
+        try:
+            self.socket.sendto(buf, self.egm_addr)
+        except socket.error:
+            return False
+        return True
+
+    def send_to_robot_cart(self, pos: np.ndarray, orient: np.ndarray, speed_ref: np.array = None,
+                           external_joints: np.array = None, external_joints_speed: np.array = None,
+                           rapid_to_robot: np.array = None, digital_signal_to_robot: bool = None) -> bool:
+        """
+        Send a cartesian command to robot. Returns False if no data has been received from the robot yet. The pose
+        is relative to the tool, workobject, and frame specified when the EGM operation is initialized. The EGM
+        operation must have been started with EGMActPose and EGMRunPose.
+
+        :param pos: The position of the TCP in millimeters [x,y,z]
+        :param orient: The orientation of the TCP in quaternions [w,x,y,z]
+        :return: True if successful, False if no data received from robot yet
+        """
+        if not self.egm_addr:
+            return False
+
+        self.send_sequence_number += 1
+        sensor_message = self._create_sensor_message_cart(pos, orient, speed_ref, external_joints,
+                                                          external_joints_speed, rapid_to_robot, digital_signal_to_robot)
+        return self._send_message(sensor_message)
+
+    def _create_sensor_message_cart(self, pos: np.ndarray, orient: np.ndarray, speed_ref: np.array,
+                                    external_joints: np.array, external_joints_speed: np.array,
+                                    rapid_to_robot: np.array, digital_signal_to_robot: bool) -> Any:
+        """Create the sensor message with cartesian data to be sent to the robot."""
+        sensor_message = egm_pb2.EgmSensor()
+        header = sensor_message.header
+        header.mtype = egm_pb2.EgmHeader.MessageType.Value('MSGTYPE_CORRECTION')
+        header.seqno = self.send_sequence_number
+        self.send_sequence_number += 1
+
+        planned = sensor_message.planned
+        speed_ref_message = sensor_message.speedRef
+
+        if pos is not None and orient is not None:
+            planned.cartesian.pos.x = pos[0]
+            planned.cartesian.pos.y = pos[1]
+            planned.cartesian.pos.z = pos[2]
+            planned.cartesian.orient.u0 = orient[0]
+            planned.cartesian.orient.u1 = orient[1]
+            planned.cartesian.orient.u2 = orient[2]
+            planned.cartesian.orient.u3 = orient[3]
+
+        if speed_ref is not None:
+            speed_ref_message.cartesians.value.extend(list(np.array(speed_ref)))
+
+        if external_joints is not None:
+            planned.externalJoints.joints.extend(list(np.array(external_joints)))
+
+        if external_joints_speed is not None:
+            speed_ref_message.externalJoints.joints.extend(list(np.array(external_joints_speed)))
+
+        if rapid_to_robot is not None:
+            sensor_message.RAPIDtoRobot.dnum.extend(list(np.array(rapid_to_robot)))
+
+        if digital_signal_to_robot is not None:
+            sensor_message.RAPIDtoRobot.digVal = digital_signal_to_robot
+
+        return sensor_message
+
+    def send_to_robot_path_corr(self, pos: np.ndarray, age: float = 1) -> bool:
+        """
+        Send a path correction command. Returns False if no data has been received from the robot yet. The path
+        correction is a displacement [x,y,z] in millimeters in **path coordinates**. The displacement uses
+        "path coordinates", which relate the direction of movement of the end effector. See `CorrConn` command in
+        *Technical reference manual RAPID Instructions, Functions and Data types* for a detailed description of path
+        coordinates.  The EGM operation must have been started with EGMActMove, and use EGMMoveL and EGMMoveC commands.
+
+        :param pos: The displacement in path coordinates in millimeters [x,y,z]
+        :return: True if successful, False if no data received from robot yet
+        """
+        self.send_sequence_number += 1
+        sensor_message = self._create_sensor_message_path_corr(pos, age)
+        return self._send_message(sensor_message)
+
+    def _create_sensor_message_path_corr(self, pos: np.ndarray, age: float) -> Any:
+        """Create the sensor message with path correction data to be sent to the robot."""
+        sensor_message = egm_pb2.EgmSensorPathCorr()
+        header = sensor_message.header
+        header.mtype = egm_pb2.EgmHeader.MessageType.Value('MSGTYPE_PATH_CORRECTION')
+        header.seqno = self.send_sequence_number
+        self.send_sequence_number += 1
+
+        path_corr = sensor_message.pathCorr
+        path_corr.pos.x = pos[0]
+        path_corr.pos.y = pos[1]
+        path_corr.pos.z = pos[2]
+        path_corr.age = age
+
+        return sensor_message
+
+    def _get_timestamps(self, robot_message: Any) -> Tuple[Optional[EGMClock], Optional[EGMTimeStamp]]:
+        clock = None
+        timestamp = None
+
+        if robot_message.HasField('feedBack'):
+            fb = robot_message.feedBack
+            if fb.HasField('time'):
+                clock = EGMClock(fb.time.sec, fb.time.usec)
+            if fb.HasField('timeStamp'):
+                timestamp = EGMTimeStamp(fb.timeStamp.sec, fb.timeStamp.nsec)
+
+        return clock, timestamp
+
+    def _get_planned_timestamps(self, robot_message: Any) -> Tuple[Optional[Tuple[int, int]], Optional[Tuple[int, int]]]:
+        """Get time and timestamp from planned data."""
+        clock = None
+        timestamp = None
+
+        if robot_message.HasField('planned'):
+            if robot_message.planned.HasField('time'):
+                clock = (robot_message.planned.time.sec,
+                         robot_message.planned.time.usec)
+            if robot_message.planned.HasField('timeStamp'):
+                timestamp = (robot_message.planned.timeStamp.sec,
+                             robot_message.planned.timeStamp.nsec)
+
+        return clock, timestamp
+
+    def _get_torque_ref(self, robot_message: Any) -> np.array:
+        """Get torque reference values."""
+        if robot_message.HasField('torqueRef'):
+            return np.array(list(robot_message.torqueRef.joints))
+        return np.array([])
+
+    def close(self):
+        """Close the connection to the robot."""
+        try:
+            self.socket.close()
+            self.socket = None
+        except socket.error:
+            pass

abbrobotegm-1.0.1/src/ABBRobotEGM.egg-info/PKG-INFO

@@ -0,0 +1,138 @@
+Metadata-Version: 2.2
+Name: ABBRobotEGM
+Version: 1.0.1
+Summary: A Python library for real-time control and data streaming of ABB robots using EGM protocol, enabling high-frequency (250Hz) communication through UDP for industrial automation applications.
+Home-page: https://github.com/FLo-ABB/ABB-EGM-Python
+Author: Florian LOBERT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: protobuf
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# ABBRobotEGM
+
+![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)
+
+`ABBRobotEGM` is a Python library for interfacing with ABB robots using Externally Guided Motion (EGM). This library provides real-time streaming communication with ABB robots at rates up to 250Hz using UDP.  It's based on the official ABB EGM [documentation](https://github.com/FLo-ABB/ABB-EGM-Python/blob/main/doc/3HAC073318%20AM%20Externally%20Guided%20Motion%20RW7-en.pdf) and examples, and it's designed to be easy to use and to integrate with other systems.
+
+## Prerequisites
+
+- Python 3.x
+- ABB RobotWare 7.X (should work with 6.X with few modifications)
+- ABB Robot with EGM option (3124-1 Externally Guided Motion)
+
+
+## Installation 🚀
+
+### Using pip 🐍
+
+To install the library using pip, run the following command:
+
+```bash
+pip install ABBRobotEGM
+```
+
+### Manual Installation 📦
+
+To use this library in your project, first download the repository and place the `ABBRobotEGM` folder in your project's directory. You can then import the `EGM` class from this library to use it in your project.
+
+## Simple Examples
+
+The repository includes several examples demonstrating different EGM functionalities. Inside each python example file, you can find the relative **RAPID** code that should be running on the robot controller.
+
+### Guidance Mode
+
+#### 1. Joint
+
+example_joint_guidance.py - Makes the first joint oscillate between -45° and +45°:
+
+#### 2. Cartesian
+example_pose_guidance.py - Makes the robot move in a circular pattern
+
+### Streaming Mode
+
+#### 1. Joint Streaming
+example_joint_stream.py - Streams robot joint positions :
+```python	
+from ABBRobotEGM import EGM
+
+def main() -> None:
+    """
+    Example showing how to stream the robot's position.
+    Be sure the robot is running before running this script.
+    """
+    with EGM() as egm:
+        while True:
+            success, state = egm.receive_from_robot()
+            if not success:
+                print("Failed to receive from robot")
+                break
+            print(f"{state.clock[1]}, {state.joint_angles[0]}, {state.joint_angles[1]}, {state.joint_angles[2]}, {state.joint_angles[3]}, {state.joint_angles[4]}, {state.joint_angles[5]}")
+
+
+if __name__ == "__main__":
+    main()
+
+```	
+
+
+#### 2. Cartesian Streaming
+example_pos_stream.py - Streams robot cartesian position
+```python	
+from ABBRobotEGM import EGM
+
+def main() -> None:
+    """
+    Example showing how to stream the robot's position.
+    Be sure the robot is running before running this script.
+    """
+    with EGM() as egm:
+        while True:
+            success, state = egm.receive_from_robot()
+            if not success:
+                print("Failed to receive from robot")
+                break
+            print(f"{state.clock[1]}, {state.cartesian.pos.x}, {state.cartesian.pos.y}, {state.cartesian.pos.z}")
+
+
+if __name__ == "__main__":
+    main()
+```
+
+### 3. Data Exchange
+example_table.py - Demonstrates exchanging data arrays with the robot
+
+## Complex Scenario
+Example of a more complex scenario where the robot is scanning a surface giving in real time its tool center point position and correlating with a sensor reading. Rspag and python code available in *"scenario scan"* folder.
+
+https://github.com/user-attachments/assets/03f151de-e098-4255-ac46-7dff42231071
+
+## Features 🚀
+
+- Real-time communication at up to 250Hz
+- Joint position control
+- Cartesian position control
+- Position streaming
+- Path corrections
+- RAPID data exchange
+- External axis support
+- Force measurement reading
+- Comprehensive robot state feedback
+
+
+## Contributing 🤝
+
+Contributions are welcome! Please feel free to submit pull requests.

abbrobotegm-1.0.1/src/ABBRobotEGM.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+MANIFEST.in
+README.md
+setup.py
+src/ABBRobotEGM/__init__.py
+src/ABBRobotEGM/abb_data.py
+src/ABBRobotEGM/egm.py
+src/ABBRobotEGM.egg-info/PKG-INFO
+src/ABBRobotEGM.egg-info/SOURCES.txt
+src/ABBRobotEGM.egg-info/dependency_links.txt
+src/ABBRobotEGM.egg-info/requires.txt
+src/ABBRobotEGM.egg-info/top_level.txt
+src/ABBRobotEGM/_egm_protobuf/__init__.py
+src/ABBRobotEGM/_egm_protobuf/egm_pb2.py

abbrobotegm-1.0.1/src/ABBRobotEGM.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

abbrobotegm-1.0.1/src/ABBRobotEGM.egg-info/requires.txt

@@ -0,0 +1,2 @@
+numpy
+protobuf

abbrobotegm-1.0.1/src/ABBRobotEGM.egg-info/top_level.txt

@@ -0,0 +1 @@
+ABBRobotEGM