The following Built-in Functions are currently restricted in simulation.

• compile
• dir
• eval
• exec
• globals
• input
• locals
• memoryview
• object
• open
• vars

The following Modules are allowed in simulation.

• machinelogic
• time
• math
• copy
• json
• abc
• random
• numpy

• Description Retrieves an AC Motor by name.
  • Parameters
    • name
      • Description The name of the AC Motor.
      • Type str
  • Returns
    • Description The AC Motor that was found.
    • Type IACMotor
  • Raises
    • Type MachineMotionException
      • Description If it is not found.

• Description Retrieves an Actuator by name.
  • Parameters
    • name
      • Description The name of the Actuator.
      • Type str
  • Returns
    • Description The Actuator that was found.
    • Type IActuator
  • Raises
    • Type MachineException
      • Description If we cannot find the Actuator.

from machinelogic import Machine

machine = Machine()
actuator = machine.get_actuator("Actuator #1")


# Always home the actuator before starting to ensure position is properly calibrated.
actuator.home(timeout=10)

start_position = actuator.state.position
print("starting at position:", start_position)

target_distance = 150.0  # mm

actuator.move_relative(
    distance=target_distance,
    timeout=10,  # seconds
)

# first_move_end_position is approx. equal to start_position + target_distance.
first_move_end_position = actuator.state.position
print("first move finished at position:", first_move_end_position)


# move back to starting position
target_distance = -1 * target_distance
actuator.move_relative(
    distance=target_distance,
    timeout=10,  # seconds
)

# approx. equal to start_position,
end_position = actuator.state.position
print("finshed back at position:", end_position)

• Description Retrieves a Bag Gripper by name.
  • Parameters
    • name
      • Description The name of the Bag Gripper
      • Type str
  • Returns
    • Description The Bag Gripper that was found.
    • Type IBagGripper
  • Raises
    • Type MachineMotionException
      • Description If it is not found.

from machinelogic import Machine, MachineException

machine = Machine()

try:
    bag_gripper = machine.get_bag_gripper(
        "New bag gripper"
    )  # Returns the bag gripper or throws
    # ...Use the bag gripper here

    # Open the bag gripper
    bag_gripper.open_async()
except MachineException as err:
    print(f"Failed to find bag gripper with name 'New bag gripper'. Reason: {str(err)}")

• Description Retrieves an DigitalInput by name.
  • Parameters
    • name
      • Description The name of the DigitalInput.
      • Type str
  • Returns
    • Description The DigitalInput that was found.
    • Type IDigitalInput
  • Raises
    • Type MachineException
      • Description If we cannot find the DigitalInput.

from machinelogic import Machine

machine = Machine()

# We are assuming here that New DigitalInput is in the MachineLogic configuration
input1 = machine.get_input("New DigitalInput")

if input1.state.value() == True:
    print("input1 is HIGH")
else:
    print("input1 is LOW")

• Description Retrieves an IMachineMotion instance by name.
  • Parameters
    • name
      • Description The name of the MachineMotion.
      • Type str
  • Returns
    • Description The MachineMotion that was found.
    • Type IMachineMotion
  • Raises
    • Type MachineException
      • Description If we cannot find the MachineMotion.

from machinelogic import Machine, MachineException

machine = Machine()

machine_motion = machine.get_machine_motion("Controller #1")

configuration = machine_motion.configuration

print("Name:", configuration.name)
print("IP Address:", configuration.ip_address)

• Description Retrieves an Output by name.
  • Parameters
    • name
      • Description The name of the Output
      • Type str
  • Returns
    • Description The Output that was found.
    • Type IOutput
  • Raises
    • Type MachineException
      • Description If we cannot find the Output.

from machinelogic import DigitalOutputException, Machine, MachineException

machine = Machine()
output1 = machine.get_output("New Output")

output1.write(True)  # Write "true" to the Output
output1.write(False)  # Write "false" to the Output

• Description Retrieves a Pneumatic by name.
  • Parameters
    • name
      • Description The name of the Pneumatic.
      • Type str
  • Returns
    • Description The Pneumatic that was found.
    • Type IPneumatic
  • Raises
    • Type MachineException
      • Description If we cannot find the Pneumatic.

from machinelogic import Machine
from time import sleep

machine = Machine()
pneumatic1 = machine.get_pneumatic("Pneumatic #1")


# Idle
pneumatic1.idle_async()
sleep(1)

# Push
pneumatic1.push_async()
sleep(1)

# Pull
pneumatic1.pull_async()
sleep(1)

• Description Retrieves a Robot by name. If no name is specified, then returns the first Robot.
  • Parameters
    • name
      • Description The Robot name. If it’s None, then the first Robot in the Robot list is returned.
      • Type str
  • Returns
    • Description The Robot that was found.
    • Type IRobot
  • Raises
    • Type MachineException
      • Description If the Robot is not found.

• Description Attach a callback function to an MQTT topic.
  • Parameters
    • topic
      • Description The topic to listen on.
      • Type str
    • callback
      • Description A callback where the first argument is the topic and the second is the message.
      • Type Union[Callable[[str, str], None], None]

from machinelogic import Machine
from time import sleep


machine = Machine()

my_event_topic = "my_custom/event/topic"


# A "callback" function called everytime a new mqtt event on my_event_topic is received.
def event_callback(topic: str, message: str):
    print("new mqtt event:", topic, message)


machine.on_mqtt_event(my_event_topic, event_callback)
machine.publish_mqtt_event(my_event_topic, "my message")

sleep(2)

machine.on_mqtt_event(my_event_topic, None)  # remove the callback.

• Description Publish an MQTT event.
  • Parameters
    • topic
      • Description Topic to publish.
      • Type str
    • message
      • Description Optional message.
      • Type Optional[str]
      • Default None

import time

from machinelogic import Machine

machine = Machine()
my_controller__1 = machine.get_machine_motion("Controller #1")
my_new_actuator = my_controller__1.get_actuator("New actuator")

while True:
    machine.publish_mqtt_event(
        "application/cycle-start",
        "{'applicationId':'e3f32b06-82ca-4f9a-b2a4-3bd6f96c9017', \
                    'cycleId':'default'}",
    )
    print("Cycle Start")
    time.sleep(5)
    machine.publish_mqtt_event(
        "application/cycle-end",
        "{'applicationId':'e3f32b06-82ca-4f9a-b2a4-3bd6f96c9017', \
                    'cycleId':'default'}",
    )
    time.sleep(1)
    print("Cycle end")

• Description MachineMotionConfiguration: The representation of the configuraiton associated with this MachineMotion.

• Description ActuatorConfiguration: The representation of the configuration associated with this MachineMotion.

• Description Home the Actuator synchronously.
  • Parameters
    • timeout
      • Description The timeout in seconds.
      • Type float
  • Raises
    • Type ActuatorException
      • Description If the home was unsuccessful or request timed out.

from machinelogic import Machine

machine = Machine()
actuator = machine.get_actuator("Actuator #1")

actuator.home(timeout=10)

• Description Locks the brakes on this Actuator.
  • Raises
    • Type ActuatorException
      • Description If the brakes failed to lock.

from machinelogic import Machine

machine = Machine()
actuator = machine.get_actuator("Actuator #1")

actuator.unlock_brakes()

# Home the actuator before starting to ensure position is properly calibrated
actuator.home(timeout=10)
actuator.move_relative(distance=100.0)

actuator.lock_brakes()

# This move will fail because the brakes are now locked.
actuator.move_relative(distance=-100.0)

• Description Moves absolute synchronously to the specified position.
  • Parameters
    • position
      • Description The position to move to.
      • Type float
    • timeout
      • Description The timeout in seconds.
      • Type float
  • Raises
    • Type ActuatorException
      • Description If the move was unsuccessful.

from machinelogic import Machine

machine = Machine()
actuator = machine.get_actuator("Actuator #1")


# Always home the actuator before starting to ensure position is properly calibrated.
actuator.home(timeout=10)


actuator.move_absolute(
    position=150.0,  # millimeters
    timeout=10,  # seconds
)

• Description Moves absolute asynchronously.
  • Parameters
    • position
      • Description The position to move to.
      • Type float
  • Raises
    • Type ActuatorException
      • Description If the move was unsuccessful.

from machinelogic import Machine
from time import sleep

machine = Machine()
actuator = machine.get_actuator("Actuator #1")

# Always home the actuator before starting to ensure position is properly calibrated.
actuator.home(timeout=10)

target_position = 150.0  # millimeters

# move_*_async will start the move and return without waiting for the move to complete.
actuator.move_absolute_async(target_position)

while actuator.state.move_in_progress:
    print("move is in progress...")
    sleep(1)

# end_position will be approx. equal to target_position.
end_position = actuator.state.position
print("finished at position", end_position)

• Description Starts a continuous move. The Actuator will keep moving until it is stopped.
  • Parameters
    • speed
      • Description The speed to move with.
      • Type float
      • Default 100.0
    • acceleration
      • Description The acceleration to move with.
      • Type float
      • Default 100.0
  • Raises
    • Type ActuatorException
      • Description If the move was unsuccessful.

from machinelogic import Machine
from time import sleep

machine = Machine()
actuator = machine.get_actuator("Actuator #1")

# Always home the actuator before starting to ensure position is properly calibrated.
actuator.home(timeout=10)

target_speed = 100.0  # mm/s
target_acceleration = 500.0  # mm/s^2
target_decceleration = 600.0  # mm/s^2

# move_*_async will start the move and return without waiting for the move to complete.
actuator.move_continuous_async(target_speed, target_acceleration)

sleep(10)  # move continuously for ~10 seconds.

actuator.stop(target_decceleration)  # deccelerate to stopped.

• Description Moves relative synchronously by the specified distance.
  • Parameters
    • distance
      • Description The distance to move.
      • Type float
    • timeout
      • Description The timeout in seconds.
      • Type float
  • Raises
    • Type ActuatorException
      • Description If the move was unsuccessful.

from machinelogic import Machine

machine = Machine()
actuator = machine.get_actuator("Actuator #1")


# Always home the actuator before starting to ensure position is properly calibrated.
actuator.home(timeout=10)

start_position = actuator.state.position
print("starting at position:", start_position)

target_distance = 150.0  # mm

actuator.move_relative(
    distance=target_distance,
    timeout=10,  # seconds
)

# first_move_end_position is approx. equal to start_position + target_distance.
first_move_end_position = actuator.state.position
print("first move finished at position:", first_move_end_position)


# move back to starting position
target_distance = -1 * target_distance
actuator.move_relative(
    distance=target_distance,
    timeout=10,  # seconds
)

# approx. equal to start_position,
end_position = actuator.state.position
print("finshed back at position:", end_position)

• Description Moves relative asynchronously by the specified distance.
  • Parameters
    • distance
      • Description The distance to move.
      • Type float
  • Raises
    • Type ActuatorException
      • Description If the move was unsuccessful.

from machinelogic import Machine
from time import sleep

machine = Machine()
actuator = machine.get_actuator("Actuator #1")

# Always home the actuator before starting to ensure position is properly calibrated.
actuator.home(timeout=10)

start_position = actuator.state.position
print("starting at position:", start_position)

target_distance = 150.0  # mm

# move_*_async will start the move and return without waiting for the move to complete.
actuator.move_relative_async(distance=150.0)

while actuator.state.move_in_progress:
    print("move is in progress...")
    sleep(1)

# end_position will be approx. equal to start_position + target_distance.
end_position = actuator.state.position
print("finished at position", end_position)

• Description Sets the max acceleration for the Actuator.
  • Parameters
    • acceleration
      • Description The new acceleration.
      • Type float
  • Raises
    • Type ActuatorException
      • Description If the request was unsuccessful.

from machinelogic import Machine

machine = Machine()
actuator = machine.get_actuator("Actuator #1")

target_speed = 100.0  # mm/s
target_acceleration = 500.0  # mm/s^2

actuator.set_speed(target_speed)
actuator.set_acceleration(target_acceleration)

• Description Sets the max speed for the Actuator.
  • Parameters
    • speed
      • Description The new speed.
      • Type float
  • Raises
    • Type ActuatorException
      • Description If the request was unsuccessful.

from machinelogic import Machine

machine = Machine()
actuator = machine.get_actuator("Actuator #1")

target_speed = 100.0  # mm/s
target_acceleration = 500.0  # mm/s^2

actuator.set_speed(target_speed)
actuator.set_acceleration(target_acceleration)

• Description ActuatorState: The representation of the current state of this MachineMotion.

• Description Stops movement on this Actuator. If no argument is provided, then a quickstop is emitted which will abruptly stop the motion. Otherwise, the actuator will decelerate following the provided acceleration.
  • Parameters
    • acceleration
      • Description Deceleration speed.
      • Type float
  • Raises
    • Type ActuatorException
      • Description If the Actuator failed to stop.

from machinelogic import Machine

machine = Machine()
actuator = machine.get_actuator("New actuator")
actuator.stop()

• Description Unlocks the brakes on this Actuator.
  • Raises
    • Type ActuatorException
      • Description If the brakes failed to unlock.

from machinelogic import Machine

machine = Machine()
actuator = machine.get_actuator("Actuator #1")

actuator.unlock_brakes()

# Home the actuator before starting to ensure position is properly calibrated
actuator.home(timeout=10)
actuator.move_relative(distance=100.0)

actuator.lock_brakes()

# This move will fail because the brakes are now locked.
actuator.move_relative(distance=-100.0)

• Description Waits for motion to complete before commencing the next action.
  • Parameters
    • timeout
      • Description The timeout in seconds, after which an exception will be thrown.
      • Type float
  • Raises
    • Type ActuatorException
      • Description If the request fails or the move did not complete in the allocated amount of time.

from machinelogic import Machine
from time import sleep

machine = Machine()
actuator = machine.get_actuator("Actuator #1")

# Always home the actuator before starting to ensure position is properly calibrated.
actuator.home(timeout=10)


target_position = 150.0  # millimeters
# move_*_async will start the move and return without waiting for the move to complete.
actuator.move_absolute_async(target_position)


print("move started...")
actuator.wait_for_move_completion(timeout=10)
print("motion complete.")


# end_position will be approx. equal to target_position.
end_position = actuator.state.position
print("finished at position", end_position)

• Description float: The current state of the brakes of the Actuator. Set to 1 if locked, otherwise 0.

from machinelogic import Machine

machine = Machine()
actuator = machine.get_actuator("New actuator")
print(actuator.state.brakes)

• Description Tuple[bool, bool]: A tuple representing the state of the [ home, end ] sensors.

from machinelogic import Machine

machine = Machine()
actuator = machine.get_actuator("New actuator")
print(actuator.state.end_sensors)

• Description bool: The boolean is True if a move is in progress, otherwise False.

from machinelogic import Machine

machine = Machine()
actuator = machine.get_actuator("New actuator")
print(actuator.state.move_in_progress)

• Description dict[str, float]: The current torque output of the Actuator.

from machinelogic import Machine

machine = Machine()
actuator = machine.get_actuator("New actuator")
print(actuator.state.output_torque)

• Description float: The current position of the Actuator.

from machinelogic import Machine

machine = Machine()
actuator = machine.get_actuator("New actuator")
print(actuator.state.position)

• Description float: The current speed of the Actuator.

from machinelogic import Machine

machine = Machine()
actuator = machine.get_actuator("New actuator")
print(actuator.state.speed)

• Description ActuatorType: The type of the Actuator.

from machinelogic import Machine

machine = Machine()
actuator = machine.get_actuator("New actuator")
print(actuator.configuration.actuator_type)

• Description Literal[“A”, “B”]: The home sensor port, either A or B.

from machinelogic import Machine

machine = Machine()
actuator = machine.get_actuator("New actuator")
print(actuator.configuration.home_sensor)

• Description str: The IP address of the Actuator.

from machinelogic import Machine

machine = Machine()
actuator = machine.get_actuator("New actuator")
print(actuator.configuration.ip_address)

• Description str: The name of the Actuator.

from machinelogic import Machine

machine = Machine()
actuator = machine.get_actuator("New actuator")
print(actuator.configuration.name)

• Description Literal[“deg”, “mm”]: The units that the Actuator functions in.

from machinelogic import Machine

machine = Machine()
actuator = machine.get_actuator("New actuator")
print(actuator.configuration.units)

• Description str: The Actuator’s ID.

from machinelogic import Machine

machine = Machine()
actuator = machine.get_actuator("New actuator")
print(actuator.configuration.uuid)

• Description Locks the brakes for all Actuators in the group.
  • Raises
    • Type ActuatorGroupException
      • Description If the brakes failed to lock on a single Actuator in the group.

from machinelogic import Machine, ActuatorGroup

machine = Machine()
actuator1 = machine.get_actuator("Actuator #1")
actuator2 = machine.get_actuator("Actuator #2")

# Always home the actuators before starting to ensure position is properly calibrated.
actuator1.home(timeout=10)
actuator2.home(timeout=10)

actuator_group = ActuatorGroup(actuator1, actuator2)
actuator_group.set_speed(100.0)  # mm/s
actuator_group.set_acceleration(500.0)  # mm/s^2

actuator_group.lock_brakes()

# This move will fail because the brakes are locked.
actuator_group.move_absolute((50.0, 120.0), timeout=10)

• Description Moves absolute synchronously to the tuple of positions.
  • Parameters
    • position
      • Description The positions to move to. Each value corresponds 1-to-1 with the actuators tuple provided to the constructor.
      • Type Tuple[float, …]
    • timeout
      • Description The timeout in seconds after which an exception is thrown.
      • Type float
      • Default DEFAULT_MOVEMENT_TIMEOUT_SECONDS
  • Raises
    • Type ActuatorGroupException
      • Description If the request fails or the timeout occurs.

from machinelogic import Machine, ActuatorGroup

machine = Machine()
actuator1 = machine.get_actuator("Actuator #1")
actuator2 = machine.get_actuator("Actuator #2")

# Always home the actuators before starting to ensure position is properly calibrated.
actuator1.home(timeout=10)
actuator2.home(timeout=10)

actuator_group = ActuatorGroup(actuator1, actuator2)
actuator_group.set_speed(100.0)  # mm/s
actuator_group.set_acceleration(500.0)  # mm/s^2


target_positions = (100.0, 200.0)  # (mm - actuator1, mm - actuator2)

actuator_group.move_absolute(target_positions, timeout=10)

• Description Moves absolute asynchronously to the tuple of positions.
  • Parameters
    • distance
      • Description The positions to move to. Each value corresponds 1-to-1 with the actuators tuple provided to the constructor.
      • Type Tuple[float, …]
  • Raises
    • Type ActuatorGroupException
      • Description If the request fails.

from machinelogic import Machine, ActuatorGroup

machine = Machine()
actuator1 = machine.get_actuator("Actuator #1")
actuator2 = machine.get_actuator("Actuator #2")

# Always home the actuators before starting to ensure position is properly calibrated.
actuator1.home(timeout=10)
actuator2.home(timeout=10)

actuator_group = ActuatorGroup(actuator1, actuator2)
actuator_group.set_speed(100.0)  # mm/s
actuator_group.set_acceleration(500.0)  # mm/s^2

target_positions = (75.0, 158.0)  # (mm - actuator1, mm - actuator2)

# move_*_async will start the move and return without waiting for the move to complete.
actuator_group.move_absolute_async(target_positions, timeout=10)
print("move started..")

actuator_group.wait_for_move_completion()
print("motion completed.")

• Description Moves relative synchronously by the tuple of distances.
  • Parameters
    • distance
      • Description The distances to move each Actuator. Each value corresponds 1-to-1 with the actuators tuple provided to the constructor.
      • Type Tuple[float, …]
    • timeout
      • Description The timeout in seconds after which an exception is thrown.
      • Type float
      • Default DEFAULT_MOVEMENT_TIMEOUT_SECONDS
  • Raises
    • Type ActuatorGroupException
      • Description If the request fails or the timeout occurs

from machinelogic import Machine, ActuatorGroup

machine = Machine()
actuator1 = machine.get_actuator("Actuator #1")
actuator2 = machine.get_actuator("Actuator #2")

# Always home the actuators before starting to ensure position is properly calibrated.
actuator1.home(timeout=10)
actuator2.home(timeout=10)

actuator_group = ActuatorGroup(actuator1, actuator2)
actuator_group.set_speed(100.0)  # mm/s
actuator_group.set_acceleration(500.0)  # mm/s^2


target_distances = (-120.0, 240.0)  # (mm - actuator1, mm - actuator2)

actuator_group.move_relative(target_distances, timeout=10)

• Description Moves relative asynchronously by the tuple of distances.
  • Parameters
    • distance
      • Description The distances to move each Actuator. Each value corresponds 1-to-1 with the actuators tuple provided to the constructor.
      • Type Tuple[float, …]
  • Raises
    • Type ActuatorGroupException
      • Description If the request fails.

from machinelogic import Machine, ActuatorGroup
from time import sleep

machine = Machine()
actuator1 = machine.get_actuator("Actuator #1")
actuator2 = machine.get_actuator("Actuator #2")

# Always home the actuators before starting to ensure position is properly calibrated.
actuator1.home(timeout=10)
actuator2.home(timeout=10)

actuator_group = ActuatorGroup(actuator1, actuator2)
actuator_group.set_speed(100.0)  # mm/s
actuator_group.set_acceleration(500.0)  # mm/s^2


target_distances = (-120.0, 240.0)  # (mm - actuator1, mm - actuator2)

# move_*_async will start the move and return without waiting for the move to complete.
actuator_group.move_relative_async(target_distances, timeout=10)

while actuator_group.move_in_progress:
    print("motion is in progress..")
    sleep(1)

print("motion complete")

• Description Sets the acceleration on all Actuators in the group.
  • Parameters
    • acceleration
      • Description The acceleration to set on all Actuators in the group.
      • Type float
  • Raises
    • Type ActuatorGroupException
      • Description If the acceleration failed to set on any Actuator in the group.

• Description Sets the speed on all Actuators in the group.
  • Parameters
    • speed
      • Description The speed to set on all Actuators in the group.
      • Type float
  • Raises
    • Type ActuatorGroupException
      • Description If the speed failed to set on any Actuator in the group.

• Description ActuatorGroupState: The state of the ActuatorGroup.

• Description Stops movement on all Actuators in the group.
  • Raises
    • Type ActuatorGroupException
      • Description If any of the Actuators in the group failed to stop.

• Description Unlocks the brakes on all Actuators in the group.
  • Raises
    • Type ActuatorGroupException
      • Description If the brakes failed to unlock on a single Actuator in the group.

from machinelogic import Machine, ActuatorGroup

machine = Machine()
actuator1 = machine.get_actuator("Actuator #1")
actuator2 = machine.get_actuator("Actuator #2")

# Always home the actuators before starting to ensure position is properly calibrated.
actuator1.home(timeout=10)
actuator2.home(timeout=10)

actuator_group = ActuatorGroup(actuator1, actuator2)
actuator_group.set_speed(100.0)  # mm/s
actuator_group.set_acceleration(500.0)  # mm/s^2

actuator_group.lock_brakes()

# This move will fail because the brakes are locked.
actuator_group.move_absolute((50.0, 120.0), timeout=10)

• Description Waits for motion to complete on all Actuators in the group.
  • Parameters
    • timeout
      • Description The timeout in seconds, after which an exception will be thrown.
      • Type float
  • Raises
    • Type ActuatorGroupException
      • Description If the request fails or the move did not complete in the allocated amount of time.

from machinelogic import Machine, ActuatorGroup

machine = Machine()
actuator1 = machine.get_actuator("Actuator #1")
actuator2 = machine.get_actuator("Actuator #2")

# Always home the actuators before starting to ensure position is properly calibrated.
actuator1.home(timeout=10)
actuator2.home(timeout=10)

actuator_group = ActuatorGroup(actuator1, actuator2)
actuator_group.set_speed(100.0)  # mm/s
actuator_group.set_acceleration(500.0)  # mm/s^2

target_positions = (75.0, 158.0)  # (mm - actuator1, mm - actuator2)

# move_*_async will start the move and return without waiting for the move to complete.
actuator_group.move_absolute_async(target_positions, timeout=10)
print("move started..")

actuator_group.wait_for_move_completion()
print("motion completed.")

• Description Computes the forward kinematics from joint angles.
  • Parameters
    • joint_angles
      • Description The 6 joint angles, in degrees.
      • Type JointAnglesDegrees
  • Returns
    • Description Cartesian pose, in mm and degrees
    • Type CartesianPose
  • Raises
    • Type ValueError
      • Description Throws an error if the joint angles are invalid.

from machinelogic import Machine

machine = Machine()
robot = machine.get_robot("New robot")

# Joint angles, in degrees
joint_angles = [
     176.68, # j1
     -35.95, # j2
      86.37, # j3
    -150.02, # j4
     -90.95, # j5
     -18.58, # j6
]
computed_robot_pose = robot.compute_forward_kinematics(joint_angles)
print(computed_robot_pose)

• Description Computes the inverse kinematics from a Cartesian pose.
  • Parameters
    • cartesian_position
      • Description The Cartesian pose, in mm and degrees,
        where the angles are extrinsic Euler angles in XYZ order.
      • Type CartesianPose
  • Returns
    • Description Joint angles, in degrees.
    • Type JointAnglesDegrees
  • Raises
    • Type ValueError
      • Description Throws an error if the inverse kinematic solver fails.

from machinelogic import Machine

machine = Machine()
robot = machine.get_robot("New robot")

cartesian_position = [
     648.71, # x in millimeters
     -313.3, # y in millimeters
     159.28, # z in millimeters
    107.143, # rx in degrees
    -145.87, # ry in degrees
    15.1261, # rz in degrees
]

computed_joint_angles = robot.compute_inverse_kinematics(cartesian_position)
print(computed_joint_angles)

• Description The Robot configuration.

• Description Creates a sequence-builder object for building a sequence of robot movements. This method is expected to be used with the append_*
  methods.
  • Returns
    • Description A sequence builder object.
    • Type SequenceBuilder

from machinelogic import Machine

machine = Machine()
robot = machine.get_robot("New robot")

# Create an arbitrary Cartesian waypoint, that is 10mm or 10 degrees away from the current position
cartesian_waypoint = [i + 10 for i in robot.state.cartesian_position]

# Create an arbitrary joint waypoint, that is 10 degrees away from the current joint angles
joint_waypoint = [i + 10 for i in robot.state.joint_angles]

cartesian_velocity = 100.0  # millimeters per second
cartesian_acceleration = 100.0  # millimeters per second squared
blend_factor_1 = 0.5

joint_velocity = 10.0  # degrees per second
joint_acceleration = 10.0  # degrees per second squared
blend_factor_2 = 0.5


with robot.create_sequence() as seq:
    seq.append_movel(
        cartesian_waypoint, cartesian_velocity, cartesian_acceleration, blend_factor_1
    )
    seq.append_movej(joint_waypoint, joint_velocity, joint_acceleration, blend_factor_2)

# Alternate Form:
seq = robot.create_sequence()
seq.append_movel(cartesian_waypoint)
seq.append_movej(joint_waypoint)
robot.execute_sequence(seq)

• Description Moves the robot through a specific sequence of joint and linear motions.
  • Parameters
    • sequence
      • Description The sequence of target points.
      • Type SequenceBuilder
  • Returns
    • Description True if successful.
    • Type bool

from machinelogic import Machine

machine = Machine()
robot = machine.get_robot("New robot")

# Create an arbitrary Cartesian waypoint, that is 10mm or 10 degrees away from the current position
cartesian_waypoint = [i + 10 for i in robot.state.cartesian_position]

# Create an arbitrary joint waypoint, that is 10 degrees away from the current joint angles
joint_waypoint = [i + 10 for i in robot.state.joint_angles]

cartesian_velocity = 100.0  # millimeters per second
cartesian_acceleration = 100.0  # millimeters per second squared
blend_factor_1 = 0.5

joint_velocity = 10.0  # degrees per second
joint_acceleration = 10.0  # degrees per second squared
blend_factor_2 = 0.5

seq = robot.create_sequence()
seq.append_movel(
    cartesian_waypoint, cartesian_velocity, cartesian_acceleration, blend_factor_1
)
seq.append_movej(joint_waypoint, joint_velocity, joint_acceleration, blend_factor_2)
robot.execute_sequence(seq)

• Description Stops the robot current movement.
  • Returns
    • Description True if the robot was successfully stopped, False otherwise.
    • Type bool

from machinelogic import Machine

machine = Machine()
robot = machine.get_robot("New robot")
robot.move_stop()

• Description Moves the robot to a specified joint position.
  • Parameters
    • target
      • Description The target joint angles, in degrees.
      • Type JointAnglesDegrees
    • velocity
      • Description The joint velocity to move at, in degrees per second.
      • Type DegreesPerSecond
    • acceleration
      • Description The joint acceleration to move at, in
        degrees per second squared.
      • Type DegreesPerSecondSquared

from machinelogic import Machine

machine = Machine()
robot = machine.get_robot("New robot")

joint_velocity = 10.0  # degrees per second
joint_acceleration = 10.0  # degrees per second squared

# Joint angles, in degrees
joint_angles = [
    86.0, # j1
     0.0, # j2
    88.0, # j3
     0.0, # j4
    91.0, # j5
     0.0, # j6
]

robot.movej(
    joint_angles,
    joint_velocity,
    joint_acceleration,
)

• Description Moves the robot to a specified Cartesian position.
  • Parameters
    • target
      • Description The target Cartesian position, in mm and degrees.
      • Type CartesianPose
    • velocity
      • Description The velocity to move at, in mm/s.
      • Type MillimetersPerSecond
    • acceleration
      • Description The acceleration to move at, in mm/s^2.
      • Type MillimetersPerSecondSquared
    • reference_frame
      • Description The reference frame to move relative to. If None,
        the robot’s base frame is used.
      • Type CartesianPose

from machinelogic import Machine

machine = Machine()
robot = machine.get_robot("New robot")

linear_velocity = 100.0  # millimeters per second
linear_acceleration = 100.0  # millimeters per second squared

# Target Cartesian pose, in millimeters and degrees
cartesian_pose = [
    -1267.8, # x in millimeters
      -89.2, # y in millimeters
      277.4, # z in millimeters
     -167.8, # rx in degrees
      179.7, # ry in degrees
      -77.8, # rz in degrees
]

reference_frame = [
      23.56, # x in millimeters
    -125.75, # y in millimeters
       5.92, # z in millimeters
       0.31, # rx in degrees
       0.65, # ry in degrees
         90, # rz in degrees
]

robot.movel(
    cartesian_pose,
    linear_velocity,  # Optional
    linear_acceleration,  # Optional
    reference_frame,  # Optional
)

• Description Set a callback to the log alarm.
  • Parameters
    • callback
      • Description A callback function to be called when a robot alarm is received.
      • Type Callable[[RobotAlarm], None]
  • Returns
    • Description The callback ID.
    • Type int

from machinelogic import Machine

machine = Machine()
robot = machine.get_robot("New robot")


# The functon defined here is called when the specified alarm occurs
def handle_log_alarm(alarm):
    print(alarm.level, alarm.error_code, alarm.description)


robot.on_log_alarm(handle_log_alarm)

• Description Registers a callback for system state changes.
  • Parameters
    • callback
      • Description The callback function.
      • Type Callable[[RobotOperationalState, RobotSafetyState], None]
  • Returns
    • Description The callback ID.
    • Type int

from machinelogic import Machine
from machinelogic.machinelogic.robot import RobotOperationalState, RobotSafetyState

machine = Machine()
robot = machine.get_robot("New robot")


# The function defined here is called when the specified state change occurs
def handle_state_change(robot_operational_state: RobotOperationalState, safety_state: RobotSafetyState):
    """
    A function that is called when the specified state change occurs.

    Args:
        robot_operational_state (RobotOperationalState): The current operational state of the robot.
        safety_state (RobotSafetyState): The current safety state of the robot.
    """
    print(robot_operational_state, safety_state)


callback_id = robot.on_system_state_change(handle_state_change)
print(callback_id)

• Description Attempts to reset the robot to a normal operational state.
  • Returns
    • Description True if successful.
    • Type bool

from machinelogic import Machine

machine = Machine()
robot = machine.get_robot("New robot")
did_reset = robot.reset()
print(did_reset)

# Robot state should be 'Normal'
print(robot.state.operational_state)

• Description Sets the payload of the robot.
  • Parameters
    • payload
      • Description The payload, in kg.
      • Type Kilograms
  • Returns
    • Description True if successful.
    • Type bool

from machinelogic import Machine

machine = Machine()
robot = machine.get_robot("New robot")

# Weight in Kilograms
weight = 2.76
is_successful = robot.set_payload(weight)
print(is_successful)

• Description Sets the tool center point offset.
  • Parameters
    • tcp_offset
      • Description The TCP offset, in mm and degrees, where the angles
        are extrinsic Euler angles in XYZ order.
      • Type CartesianPose
  • Returns
    • Description True if the TCP offset was successfully set, False otherwise.
    • Type bool

from machinelogic import Machine

machine = Machine()
robot = machine.get_robot("New robot")

cartesian_offset = [
     10.87, # x in millimeters
    -15.75, # y in millimeters
    200.56, # z in millimeters
      0.31, # rx degrees
      0.65, # ry degrees
         0, # rz degrees
]

is_successful = robot.set_tcp_offset(cartesian_offset)
print(is_successful)

• Description Sets the value of a tool digital output.
  • Parameters
    • pin
      • Description The pin number.
      • Type int
    • value
      • Description The value to set, where 1 is high and 0 is low.
      • Type int
  • Returns
    • Description True if successful.
    • Type bool

from machinelogic import Machine

machine = Machine()
# New robot must be configured in the Configuration pane
robot = machine.get_robot("New robot")

# digital output identifier
output_pin = 1
value = 0
is_successful = robot.set_tool_digital_output(output_pin, value)
print(is_successful)

• Description The current Robot state.

• Description Put the robot into teach mode (i.e., freedrive).
  • Returns
    • Description A context manager that will exit teach mode when it is closed.
    • Type _WithTeach

import time

from machinelogic import Machine

machine = Machine()
robot = machine.get_robot("New robot")

with robot.teach_mode():  # When all arguments inside this statement are complete, teach mode ends automatically
    print("Robot is now in teach mode for 5 seconds")
    time.sleep(5)

    # Robot should be in 'Freedrive'
    print(robot.state.operational_state)
    time.sleep(1)

time.sleep(1)

# Robot should be back to 'Normal'
print(robot.state.operational_state)

• Description The current Cartesian position of the robot, in mm and degrees.

from machinelogic import Machine

machine = Machine()
robot = machine.get_robot("New robot")
print(robot.state.cartesian_position)

• Description Returns the value of a digital input at a given pin.
  • Parameters
    • pin
      • Description The pin number.
      • Type int
  • Returns
    • Description True if the pin is high, False otherwise.
    • Type None

from machinelogic import Machine

machine = Machine()
robot = machine.get_robot("New robot")
print(robot.state.get_digital_input_value(0))

• Description The robot current joint angles.

from machinelogic import Machine

machine = Machine()
robot = machine.get_robot("New robot")
print(robot.state.joint_angles)

• Description The current robot operational state.

from machinelogic import Machine

machine = Machine()
robot = machine.get_robot("New robot")
print(robot.state.operational_state)

• Description The current robot safety state.

from machinelogic import Machine

machine = Machine()
robot = machine.get_robot("New robot")
print(robot.state.safety_state)

• Description The maximum Cartesian velocity of the robot, in mm/s.

from machinelogic import Machine

machine = Machine()
robot = machine.get_robot("New robot")
print(robot.configuration.cartesian_velocity_limit)

• Description The robot joints’ maximum angular velocity, in deg/s.

from machinelogic import Machine

machine = Machine()
robot = machine.get_robot("New robot")
print(robot.configuration.joint_velocity_limit)

• Description The friendly name of the robot.

from machinelogic import Machine

machine = Machine()
robot = machine.get_robot("New robot")
print(robot.configuration.name)

• Description The robot’s type.

from machinelogic import Machine

machine = Machine()
robot = machine.get_robot("New robot")
print(robot.configuration.robot_type)

• Description The robot’s ID.

from machinelogic import Machine

machine = Machine()
robot = machine.get_robot("New robot")
print(robot.configuration.uuid)

• Description Append a movej to the sequence.
  • Parameters
    • target
      • Description The target joint angles, in degrees.
      • Type JointAngles
    • velocity
      • Description The velocity of the move, in degrees per second.
      • Type DegreesPerSecond
      • Default 10.0
    • acceleration
      • Description The acceleration of the move, in degrees per second squared.
      • Type DegreesPerSecondSquared
      • Default 10.0
    • blend_radius
      • Description The blend radius of the move, in millimeters.
      • Type Millimeters
      • Default 0.0
  • Returns
    • Description The builder.
    • Type SequenceBuilder

• Description Append a movel to the sequence.
  • Parameters
    • target
      • Description The target pose.
      • Type CartesianPose
    • velocity
      • Description The velocity of the move, in millimeters per second.
      • Type MillimetersPerSecond
      • Default 100.0
    • acceleration
      • Description The acceleration of the move, in millimeters per second squared.
      • Type MillimetersPerSecondSquared
      • Default 100.0
    • blend_radius
      • Description The blend radius of the move, in millimeters.
      • Type Millimeters
      • Default 0.0
    • reference_frame
      • Description The reference frame for the target pose.
      • Type CartesianPose
      • Default None
  • Returns
    • Description The builder.
    • Type SequenceBuilder

• Description DigitalInputConfiguration: The configuration of the DigitalInput.

• Description DigitalInputState: The state of the DigitalInput.

from machinelogic import Machine

machine = Machine()

# We are assuming here that New DigitalInput is in the MachineLogic configuration
input1 = machine.get_input("New DigitalInput")

if input1.state.value() == True:
    print("input1 is HIGH")
else:
    print("input1 is LOW")

• Description bool: The current value of the IO pin. True means high, while False means low. This is different from active/inactive, which depends on the active_high configuration.

• Description bool: The value that needs to be set to consider the DigitalInput/DigitalOutput as active.

• Description int: The device number of the DigitalInput/DigitalOutput.

• Description str: The ip address of the DigitalInput/DigitalOutput.

• Description str: The name of the DigitalInput/DigitalOutput.

• Description int: The port number of the DigitalInput/DigitalOutput.

• Description str: The unique ID of the DigitalInput/DigitalOutput.

• Description OutputConfiguration: The configuration of the Output.

• Description Writes the value into the Output, with True being high and False being low.
  • Parameters
    • value
      • Description The value to write to the Output.
      • Type bool
  • Raises
    • Type DigitalOutputException
      • Description If we fail to write the value to the Output.

from machinelogic import DigitalOutputException, Machine, MachineException

machine = Machine()
output1 = machine.get_output("New Output")

output1.write(True)  # Write "true" to the Output
output1.write(False)  # Write "false" to the Output

• Description bool: The current value of the IO pin. True means high, while False means low. This is different from active/inactive, which depends on the active_high configuration.

• Description bool: The value that needs to be set to consider the DigitalInput/DigitalOutput as active.

• Description int: The device number of the DigitalInput/DigitalOutput.

• Description str: The ip address of the DigitalInput/DigitalOutput.

• Description str: The name of the DigitalInput/DigitalOutput.

• Description int: The port number of the DigitalInput/DigitalOutput.

• Description str: The unique ID of the DigitalInput/DigitalOutput.

• Description

• Description Exception.with_traceback(tb) – set self.traceback to tb and return self.

• Description

• Description Exception.with_traceback(tb) – set self.traceback to tb and return self.

• Description

• Description Exception.with_traceback(tb) – set self.traceback to tb and return self.

• Description

• Description Exception.with_traceback(tb) – set self.traceback to tb and return self.

• Description

• Description Exception.with_traceback(tb) – set self.traceback to tb and return self.

• Description

• Description Exception.with_traceback(tb) – set self.traceback to tb and return self.

• Description

• Description Exception.with_traceback(tb) – set self.traceback to tb and return self.

• Description

• Description Exception.with_traceback(tb) – set self.traceback to tb and return self.

• Description PneumaticConfiguration: The configuration of the actuator.

• Description Idles the Pneumatic.
  • Raises
    • Type PneumaticException
      • Description If the idle was unsuccessful.

• Description Pulls the Pneumatic.
  • Raises
    • Type PneumaticException
      • Description If the pull was unsuccessful.

• Description Pushes the Pneumatic.
  • Raises
    • Type PneumaticException
      • Description If the push was unsuccessful.

• Description PneumaticState: The state of the actuator.

• Description int: The device of the axis.

• Description Optional[int]: The optional pull in pin.

• Description Optional[int]: The optional push in pin.

• Description str: The IP address of the axis.

• Description str: The name of the Pneumatic.

• Description int: The pull out pin of the axis.

• Description int: The push out pin of the axis.

• Description str: The ID of the Pneumatic.

• Description ACMotorConfiguration: The configuration of the ACMotor.

• Description Begins moving the AC Motor forward.
  • Raises
    • Type ACMotorException
      • Description If the move was unssuccessful.

from time import sleep
from machinelogic import Machine

machine = Machine()
ac_motor1 = machine.get_ac_motor("AC Motor #1")

ac_motor1.move_forward()
sleep(10)
ac_motor1.stop()

• Description Begins moving the AC Motor in reverse.
  • Raises
    • Type ACMotorException
      • Description If the move was unssuccessful.

from time import sleep
from machinelogic import Machine

machine = Machine()
ac_motor1 = machine.get_ac_motor("AC Motor #1")

# Move the AC motor in reverse
ac_motor1.move_reverse()

# The AC motor will stop moving if the program terminates
sleep(10)

• Description Stops the movement of the AC Motor.
  • Raises
    • Type ACMotorException
      • Description If the stop was unssuccessful.

from time import sleep
from machinelogic import Machine

machine = Machine()

ac_motor1 = machine.get_ac_motor("AC Motor #1")

# Move the AC Motor forwards
ac_motor1.move_forward()

# Do something here
sleep(10)

ac_motor1.stop()

• Description int: The device of the axis.

• Description str: The IP address of the axis.

• Description str: The name of the Pneumatic.

• Description int: The push out pin of the axis.

• Description int: The pull out pin of the axis.

• Description str: The ID of the Pneumatic.

• Description Closes the Bag Gripper.
  • Raises
    • Type BagGripperException
      • Description If the Bag Gripper fails to close.

from time import sleep
from machinelogic import Machine

machine = Machine()
bag_gripper1 = machine.get_bag_gripper("Bag Gripper #1")

# Open the Bag Gripper
bag_gripper1.open_async()

# You can do something while the Bag Gripper is open
sleep(10)

# Close the Bag Gripper
bag_gripper1.close_async()

• Description BagGripperConfiguration: The configuration of the actuator.

• Description Opens the Bag Gripper.
  • Raises
    • Type BagGripperException
      • Description If the Bag Gripper fails to open.

from time import sleep
from machinelogic import Machine

machine = Machine()
bag_gripper1 = machine.get_bag_gripper("Bag Gripper #1")

bag_gripper1.open(wait_for_move_completion=True)
print("bag_gripper1 is now open.")

sleep(5)

bag_gripper1.close(wait_for_move_completion=True)
print("bag_gripper1 is now closed.")

• Description BagGripperState: The state of the actuator.

• Description int: The device of the Bag gripper.

• Description int: The close in pin of the Bag gripper.

• Description int: The open in pin of the Bag gripper.

• Description str: The IP address of the Bag gripper.

• Description str: The name of the Bag gripper.

• Description int: The close out pin of the Bag gripper.

• Description int: The open out pin of the Bag gripper.

• Description str: The ID of the Bag gripper.