machine-logic-sdk v2.0.0

Added

New MotionProfile class for defining Actuator and ActuatorGroup motion profiles (`move_absolute`, move_absolute_async, move_relative, move_relative_async, move_continuous_asyc). Import directly from machinelogic.

• motion_profile.velocity

• motion_profile.acceleration

• motion_profile.jerk

Changed

• Actuator:

  • new arguments for `actuator.move_absolute:` (position: float, motion_profile: MotionProfile)

  • new arguments for `actuator.move_absolute_async:` (position: float, motion_profile: MotionProfile)

  • new arguments for `actuator.move_relative:` (position: float, motion_profile: MotionProfile)

  • new arguments for `actuator.move_relative_async:` (position: float, motion_profile: MotionProfile)

  • new arguments for `actuator.move_continuous_async:` (position: float, motion_profile: MotionProfile)

  • Removed acceleration argument from actuator.stop() method.

• ActuatorGroup:

  • new arguments for `actuator_group.move_absolute:` (position: float, motion_profile: MotionProfile)

  • new arguments for `actuator_group.move_absolute_async:` (position: float, motion_profile: MotionProfile)

  • new arguments for `actuator_group.move_relative:` (position: float, motion_profile: MotionProfile)

  • new arguments for `actuator_group.move_relative_async:` (position: float, motion_profile: MotionProfile)

  • new arguments for `actuator_group.move_continuous_async:` (position: float, motion_profile: MotionProfile)

  • Removed acceleration argument from actuator_group.stop() method.

• DigitalInput, `DigitalOutput` Pneumatic and ACMotor classes:

  • replaced [class].configuration.device with [class].configuration.device_id

  • replaced [class].configuration.port with [class].configuration.pin

  • added [class].configuration.controller_port

Removed

• removed actuator.set_speed (replaced with MotionProfile sent directly to move)

• removed actuator.set_acceleration (replaced with MotionProfile sent directly to move)

• removed actuator.lock_brakes method  

• removed actuator.unlock_brakes method  

• removed actuator.state.brake

• removed actuator_group.set_speed (replaced with MotionProfile sent directly to move)

• removed actuator_group.set_acceleration (replaced with MotionProfile sent directly to move)

• removed actuator_group.lock_brakes

• removed actuator_group.unlock_brakes

• Removed BagGripper as configurable item from machinelogic

  • Removed BagGripper Class

  • Removed Machine.get_bag_gripper

  • Removed BagGripperConfiguration

• Description The state of the Machine.

• Type MachineState

• 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 ACMotor

• 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 Actuator

• Raises

  • Type MachineException

  • Description If we cannot find the Actuator.

from machinelogic import Machine, MotionProfile

machine = Machine()
my_actuator = machine.get_actuator("Actuator")


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

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

TARGET_DISTANCE = 150 # millimeters
VELOCITY = 150.0 # mm/s
ACCELERATION = 150.0 # mm/s^2
JERK = 150.0 # mm/s^3 OPTIONAL PARAMETER

new_motion_profile = MotionProfile(velocity=VELOCITY, acceleration=ACCELERATION, jerk=JERK)

my_actuator.move_relative(
    distance=TARGET_DISTANCE,
    motion_profile=new_motion_profile,
)

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


# move back to starting position
TARGET_DISTANCE = -1 * TARGET_DISTANCE
my_actuator.move_relative(
    distance=TARGET_DISTANCE,
    motion_profile=new_motion_profile,
)

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

• Description Retrieves an DigitalInput by name.

• Parameters

  • name

    • Description The name of the DigitalInput.

    • Type str

• Returns

  • Description The DigitalInput that was found.

  • Type DigitalInput

• Raises

  • Type MachineException

  • Description If we cannot find the DigitalInput.

from machinelogic import Machine

machine = Machine()

my_input = machine.get_input("Input")

if my_input.state.value:
    print(f"{my_input.configuration.name} is HIGH")
else:
    print(f"{my_input.configuration.name} 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 MachineMotion

• Raises

  • Type MachineException

  • Description If we cannot find the MachineMotion.

from machinelogic import Machine, MachineException

machine = Machine()

my_controller_1 = machine.get_machine_motion("Controller 1")

configuration = my_controller_1.configuration

print("Name:", configuration.name)

• 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 Machine, MachineException, DigitalOutputException

machine = Machine()
my_output = machine.get_output("Output")

my_output.write(True)  # Write "true" to the Output
my_output.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 Pneumatic

• Raises

  • Type MachineException

  • Description If we cannot find the Pneumatic.

import time
from machinelogic import Machine

machine = Machine()
my_pneumatic = machine.get_pneumatic("Pneumatic")


# Idle
my_pneumatic.idle_async()
time.sleep(1)

# Push
my_pneumatic.push_async()
time.sleep(1)

# Pull
my_pneumatic.pull_async()
time.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 Robot

• Raises

  • Type MachineException

  • Description If the Robot is not found.

from machinelogic import Machine

machine = Machine()
my_robot = machine.get_robot("Robot")

# Example of use: moving robot to specified joint angles in deg
my_robot.movej([0, -90, 120, -90, -90, 0])

• Description Returns the scene instance

• Returns

  • Description The instance of the scene containing the scene assets.

  • Type Scene

• Raises

  • Type MachineException

  • Description If failed to find the scene

• 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]

import time
from machinelogic import Machine


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")

time.sleep(2)

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

• Description Adds a change listener to execute when the Machine state changes.

• Parameters

  • callback

    • Description The callback

    • Type Callable[[MachineOperationalState, MachineSafetyState], None]

from machinelogic import Machine

machine = Machine()

# Callback function called everytime a new system state is received.
def on_machine_state_change_callback(operational_state, safety_state):
    print('New Machine Operational State', operational_state)
    print('New Machine Safety State', safety_state)

# To set an on_system_state_change callback
machine.on_system_state_change(on_machine_state_change_callback)

# To remove the callback
machine.on_system_state_change(None)

• Description Publish an MQTT event.

• Parameters

  • topic

    • Description Topic to publish.

    • Type str

  • message

    • Description Optional message. Defaults to None.

    • Type Optional[str]

import time
import json
from machinelogic import Machine

machine = Machine()

# Example for publishing a cycle-start and cycle-end topic and message
# to track application cycles in MachineAnalytics
cycle_start_topic = "application/cycle-start"
cycle_end_topic = "application/cycle-end"
cycle_message = {
    "applicationId":"My Python Application",
    "cycleId":"default"
    }
json_cycle_message = json.dumps(cycle_message)

while True:
    machine.publish_mqtt_event(cycle_start_topic, json_cycle_message)
    print("Cycle Start")
    time.sleep(5)
    machine.publish_mqtt_event(cycle_end_topic, json_cycle_message)
    time.sleep(1)
    print("Cycle end")

• Description Reset the machine by trying to clear drive errors.

• Returns

  • Description True if the machine was reset successfully, False otherwise.

  • Type bool

from machinelogic import Machine

machine = Machine()

# Example for resetting the machine if the MachineOperationalState is
# NON_OPERATIONAL. The reset programmatically tries to clear drive errors

if machine.state.operational_state == "NON_OPERATIONAL":
    machine.reset()
    print("Machine Reset")

• Description The operational state of the Machine.

• Type MachineOperationalState

• Description The safety state of the Machine.

• Type MachineSafetyState

Description: The machine's operational state.

• NON_OPERATIONAL= 0

• NORMAL= 1

Description: The machine's safety state.

• ERROR= -1

• NONE= 0

• EMERGENCY_STOP= 1

• NORMAL= 2

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

• Type MachineMotionConfiguration

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

• Type ActuatorConfiguration

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

• Type ActuatorState

• 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()
my_actuator = machine.get_actuator("Actuator")

my_actuator.home(timeout=10)

• Description Moves absolute synchronously to the specified position.

• Parameters

  • position

    • Description The position to move to.

    • Type float

  • motion_profile

    • Description The motion profile to move with. See MotionProfile class.

    • Type MotionProfile

• Raises

  • Type ActuatorException

  • Description If the move was unsuccessful.

from machinelogic import Machine, MotionProfile

machine = Machine()
my_actuator = machine.get_actuator("Actuator")


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

TARGET_POSITION = 150.0 # millimeters
VELOCITY = 150.0 # mm/s
ACCELERATION = 150.0 # mm/s^2
JERK = 150.0 # mm/s^3 OPTIONAL PARAMETER

my_actuator.move_absolute(
    position=TARGET_POSITION,  # millimeters
    motion_profile=MotionProfile(velocity=VELOCITY, acceleration=ACCELERATION, jerk=JERK),
    timeout=10,  # seconds
)

• Description Moves absolute asynchronously.

• Parameters

  • position

    • Description The position to move to.

    • Type float

  • motion_profile

    • Description The motion profile to move with. See MotionProfile class.

    • Type MotionProfile

• Raises

  • Type ActuatorException

  • Description If the move was unsuccessful.

import time
from machinelogic import Machine, MotionProfile

machine = Machine()
my_actuator = machine.get_actuator("Actuator")

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

TARGET_POSITION = 150.0 # millimeters
VELOCITY = 150.0 # mm/s
ACCELERATION = 150.0 # mm/s^2
JERK = 150.0 # mm/s^3 OPTIONAL PARAMETER

new_motion_profile = MotionProfile(velocity=VELOCITY, acceleration=ACCELERATION, jerk=JERK)

# move_absolute_async will start the move and return without waiting for the move to complete.
my_actuator.move_absolute_async(position=TARGET_POSITION, motion_profile=new_motion_profile)

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

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

• Description Starts a continuous move. The Actuator will keep moving until it is stopped.

• Parameters

  • motion_profile

    • Description The motion profile to move with. See MotionProfile class. Note: Actuator.move_continuous_async does not support jerk. If jerk is provided in the MotionProfile, a warning will be raised and the move will continue without jerk.

    • Type MotionProfile

• Raises

  • Type ActuatorException

  • Description If the move was unsuccessful.

import time
from machinelogic import Machine, MotionProfile

machine = Machine()
my_actuator = machine.get_actuator("Actuator")

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

# Continuous motion profile only uses velocity and acceleration.
VELOCITY = 100.0 # mm/s
ACCELERATION = 100.0 # mm/s^2

new_motion_profile = MotionProfile(velocity=VELOCITY, acceleration=ACCELERATION)

# move_continuous_async will start the move and return without waiting for the move to complete.
my_actuator.move_continuous_async(motion_profile=new_motion_profile)

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

my_actuator.stop()  # decelerate to stopped.

• Description Moves relative synchronously by the specified distance.

• Parameters

  • distance

    • Description The distance to move.

    • Type float

  • motion_profile

    • Description The motion profile to move with. See MotionProfile class.

    • Type MotionProfile

• Raises

  • Type ActuatorException

  • Description If the move was unsuccessful.

from machinelogic import Machine, MotionProfile

machine = Machine()
my_actuator = machine.get_actuator("Actuator")


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

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

TARGET_DISTANCE = 150 # millimeters
VELOCITY = 150.0 # mm/s
ACCELERATION = 150.0 # mm/s^2
JERK = 150.0 # mm/s^3 OPTIONAL PARAMETER

new_motion_profile = MotionProfile(velocity=VELOCITY, acceleration=ACCELERATION, jerk=JERK)

my_actuator.move_relative(
    distance=TARGET_DISTANCE,
    motion_profile=new_motion_profile,
)

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


# move back to starting position
TARGET_DISTANCE = -1 * TARGET_DISTANCE
my_actuator.move_relative(
    distance=TARGET_DISTANCE,
    motion_profile=new_motion_profile,
)

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

• Description Moves relative asynchronously by the specified distance.

• Parameters

  • distance

    • Description The distance to move.

    • Type float

  • motion_profile

    • Description The motion profile to move with. See MotionProfile class.

    • Type MotionProfile

• Raises

  • Type ActuatorException

  • Description If the move was unsuccessful.

import time
from machinelogic import Machine, MotionProfile

machine = Machine()
my_actuator = machine.get_actuator("Actuator")

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

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

TARGET_DISTANCE = 150 # millimeters
VELOCITY = 150.0 # mm/s
ACCELERATION = 150.0 # mm/s^2
JERK = 150.0 # mm/s^3 OPTIONAL PARAMETER

new_motion_profile = MotionProfile(velocity=VELOCITY, acceleration=ACCELERATION, jerk=JERK)

# move_relative_async will start the move and return without waiting for the move to complete.
my_actuator.move_relative_async(distance=TARGET_DISTANCE, motion_profile=new_motion_profile)

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

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

• Description Stops movement on this Actuator as quickly as possible.

• Raises

  • Type ActuatorException

  • Description If the Actuator failed to stop.

from machinelogic import Machine

machine = Machine()
my_actuator = machine.get_actuator("Actuator")

my_actuator.stop()
# The actuator will stop as quickly as possible.

• 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, MotionProfile

machine = Machine()
my_actuator = machine.get_actuator("Actuator")

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


TARGET_POSITION = 150.0 # millimeters
VELOCITY = 150.0 # mm/s
ACCELERATION = 150.0 # mm/s^2

new_motion_profile = MotionProfile(velocity=VELOCITY, acceleration=ACCELERATION)

# move_absolute_async will start the move and return without waiting for the move to complete.
my_actuator.move_absolute_async(position=TARGET_POSITION, motion_profile=new_motion_profile)


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


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

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

• Type typing.Tuple[bool, bool]

from machinelogic import Machine

machine = Machine()
my_actuator = machine.get_actuator("Actuator")
print(my_actuator.state.end_sensors)

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

• Type bool

from machinelogic import Machine

machine = Machine()
my_actuator = machine.get_actuator("Actuator")
print(my_actuator.state.move_in_progress)

• Description The current torque output of the Actuator.

• Type dict

from machinelogic import Machine

machine = Machine()
my_actuator = machine.get_actuator("Actuator")
print(my_actuator.state.output_torque)

• Description The current position of the Actuator.

• Type float

from machinelogic import Machine

machine = Machine()
my_actuator = machine.get_actuator("Actuator")
print(my_actuator.state.position)

• Description The current speed of the Actuator.

• Type float

from machinelogic import Machine

machine = Machine()
my_actuator = machine.get_actuator("Actuator")
print(my_actuator.state.speed)

• Description The type of the Actuator.

• Type typing.Literal['belt', 'rack_and_pinion', 'rack_and_pinion_v2', 'ball_screw', 'enclosed_ball_screw', 'enclosed_lead_screw', 'indexer', 'indexer_v2', 'electric_cylinder', 'belt_conveyor', 'roller_conveyor', 'pneumatic', 'ac_motor_with_vfd', 'enclosed_timing_belt', 'belt_rack', 'heavy_duty_roller_conveyor', 'timing_belt_conveyor', 'telescopic_column', 'custom']

from machinelogic import Machine

machine = Machine()
my_actuator = machine.get_actuator("Actuator")
print(my_actuator.configuration.actuator_type)

• Description The controller id of the Actuator

• Type str

• Description The home sensor port, either A or B.

• Type typing.Literal['A', 'B']

from machinelogic import Machine

machine = Machine()
my_actuator = machine.get_actuator("Actuator")
print(my_actuator.configuration.home_sensor)

• Description The name of the Actuator.

• Type str

from machinelogic import Machine

machine = Machine()
my_actuator = machine.get_actuator("Actuator")
print(my_actuator.configuration.name)

• Description The units that the Actuator functions in.

• Type typing.Literal['deg', 'mm']

from machinelogic import Machine

machine = Machine()
my_actuator = machine.get_actuator("Actuator")
print(my_actuator.configuration.units)

• Description The Actuator's ID.

• Type str

from machinelogic import Machine

machine = Machine()
my_actuator = machine.get_actuator("Actuator")
print(my_actuator.configuration.uuid)

• Description The state of the ActuatorGroup.

• Type ActuatorGroupState

• 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, ...]

  • motion_profile

    • Description The motion profile to move with. See MotionProfile class.

    • Type MotionProfile

• Raises

  • Type ActuatorGroupException

  • Description If the request fails or the timeout occurs.

from machinelogic import Machine, ActuatorGroup, MotionProfile

machine = Machine()
my_actuator_1 = machine.get_actuator("Actuator 1")
my_actuator_2 = machine.get_actuator("Actuator 2")

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

actuator_group = ActuatorGroup(my_actuator_1, my_actuator_2)

TARGET_POSITIONS = (100.0, 200.0)  # (mm - actuator1, mm - actuator2)
VELOCITY = 150.0 # mm/s
ACCELERATION = 150.0 # mm/s^2
JERK = 150.0 # mm/s^3 OPTIONAL PARAMETER

new_motion_profile = MotionProfile(velocity=VELOCITY, acceleration=ACCELERATION, jerk=JERK)

actuator_group.move_absolute(position=TARGET_POSITIONS, motion_profile=new_motion_profile)

• 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, ...]

  • motion_profile

    • Description The motion profile to move with. See MotionProfile class.

    • Type MotionProfile

• Raises

  • Type ActuatorGroupException

  • Description If the request fails.

from machinelogic import Machine, ActuatorGroup, MotionProfile

machine = Machine()
my_actuator_1 = machine.get_actuator("Actuator 1")
my_actuator_2 = machine.get_actuator("Actuator 2")

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

actuator_group = ActuatorGroup(my_actuator_1, my_actuator_2)

TARGET_POSITIONS = (75.0, 158.0)  # (mm - actuator1, mm - actuator2)
VELOCITY = 150.0 # mm/s
ACCELERATION = 150.0 # mm/s^2
JERK = 150.0 # mm/s^3 OPTIONAL PARAMETER

new_motion_profile = MotionProfile(velocity=VELOCITY, acceleration=ACCELERATION, jerk=JERK)

# move_absolute_async will start the move and return without waiting for the move to complete.
actuator_group.move_absolute_async(position=TARGET_POSITIONS, motion_profile=new_motion_profile)
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, ...]

  • motion_profile

    • Description The motion profile to move with. See MotionProfile class.

    • Type MotionProfile

• Raises

  • Type ActuatorGroupException

  • Description If the request fails or the timeout occurs

from operator import ne
from machinelogic import Machine, ActuatorGroup, MotionProfile

machine = Machine()
my_actuator_1 = machine.get_actuator("Actuator 1")
my_actuator_2 = machine.get_actuator("Actuator 2")

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

actuator_group = ActuatorGroup(my_actuator_1, my_actuator_2)


TARGET_DISTANCES = (-120.0, 240.0)  # (mm - actuator1, mm - actuator2)
VELOCITY = 150.0 # mm/s
ACCELERATION = 150.0 # mm/s^2
JERK = 150.0 # mm/s^3 OPTIONAL PARAMETER

new_motion_profile = MotionProfile(velocity=VELOCITY, acceleration=ACCELERATION, jerk=JERK)

actuator_group.move_relative(distance=TARGET_DISTANCES, motion_profile=new_motion_profile)

• 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, ...]

  • motion_profile

    • Description The motion profile to move with. See MotionProfile class.

    • Type MotionProfile

• Raises

  • Type ActuatorGroupException

  • Description If the request fails.

import time
from machinelogic import Machine, ActuatorGroup, MotionProfile

machine = Machine()
actuator1 = machine.get_actuator("My Actuator #1")
actuator2 = machine.get_actuator("My 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)

TARGET_DISTANCES = (-120.0, 240.0)  # (mm - actuator1, mm - actuator2)
VELOCITY = 150.0 # mm/s
ACCELERATION = 150.0 # mm/s^2
JERK = 150.0 # mm/s^3 OPTIONAL PARAMETER

new_motion_profile = MotionProfile(velocity=VELOCITY, acceleration=ACCELERATION, jerk=JERK)

# move_relative_async will start the move and return without waiting for the move to complete.
actuator_group.move_relative_async(distance=TARGET_DISTANCES, motion_profile=new_motion_profile)

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

print("motion complete")

• 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 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, MotionProfile

machine = Machine()
my_actuator_1 = machine.get_actuator("Actuator 1")
my_actuator_2 = machine.get_actuator("Actuator 2")

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

actuator_group = ActuatorGroup(my_actuator_1, my_actuator_2)

TARGET_POSITIONS = (75.0, 158.0)  # (mm - actuator1, mm - actuator2)
VELOCITY = 150.0 # mm/s
ACCELERATION = 150.0 # mm/s^2
JERK = 150.0 # mm/s^3 OPTIONAL PARAMETER

new_motion_profile = MotionProfile(velocity=VELOCITY, acceleration=ACCELERATION, jerk=JERK)

# move_absolute_async will start the move and return without waiting for the move to complete.
actuator_group.move_absolute_async(position=TARGET_POSITIONS, motion_profile=new_motion_profile)
print("move started..")

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

• Description The Robot configuration.

• Type RobotConfiguration

• Description The current Robot state.

• Type RobotState

• 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()
my_robot = machine.get_robot("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 = my_robot.compute_forward_kinematics(joint_angles)
print(computed_robot_pose)

• Description Computes the inverse kinematics from a Cartesian pose.

• Parameters

  • cartesian_position

    • Description The end effector's pose, in mm and degrees, where the angles are extrinsic Euler angles in XYZ order.

    • Type CartesianPose

  • joint_constraints

    • Description A list of joint constraints. Length of list can be between 1 and number of joints on robot.

    • Type Optional[List[IGenericJointConstraint]]

  • seed_position

    • Description The seed joint angles, in degrees (as start position for IK search)

    • Type Optional[JointAnglesDegrees]

• 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()
my_robot = machine.get_robot("Robot")

cartesian_position = [
     648.71,  # x in millimeters
    -313.30,  # y in millimeters
     159.28,  # z in millimeters
     107.14,  # rx in degrees
    -145.87,  # ry in degrees
      15.13,  # rz in degrees
]

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

• Description Creates a sequence-builder object for building a sequence of robot

• Returns

  • Description A sequence builder object.

  • Type SequenceBuilder

from machinelogic import Machine

machine = Machine()
my_robot = machine.get_robot("Robot")

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

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

cartesian_velocity = 100.0  # millimeters per second
cartesian_acceleration = 100.0  # millimeters per second squared
blend_factor_1 = 0.5
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.00,  # rz in degrees
]

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


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

# Alternate Form:
seq = my_robot.create_sequence()
seq.append_movel(cartesian_waypoint)
seq.append_movej(joint_waypoint)
my_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()
my_robot = machine.get_robot("Robot")

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

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

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 = my_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)
my_robot.execute_sequence(seq)

• Description Moves the robot through a specific sequence of joint and linear motions asynchronously.

• Parameters

  • sequence

    • Description The sequence of target points.

    • Type SequenceBuilder

• Returns

  • Description True if successful.

  • Type bool

from machinelogic import Machine

machine = Machine()
my_robot = machine.get_robot("Robot")

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

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

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 = my_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)

my_robot.execute_sequence_async(seq)

print("Robot is executing sequence asynchronously.")
my_robot.wait_for_motion_completion()
print("Robot has finished executing sequence.")

• 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()
my_robot = machine.get_robot("Robot")

my_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()
my_robot = machine.get_robot("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
]

my_robot.movej(
    joint_angles,
    joint_velocity,
    joint_acceleration,
)

• Description Moves the robot to a specified joint position asynchronously.

• 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()
my_robot = machine.get_robot("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
]

my_robot.movej_async(
  joint_angles,
  joint_velocity,
  joint_acceleration,
)
print("Robot is moving asynchronously to the specified joint angles.")
my_robot.wait_for_motion_completion()
print("Robot has finished moving to the specified joint angles.")

• Description Moves the robot to a specified Cartesian position.

• Parameters

  • target

    • Description The end effector's pose, in mm and degrees, where the angles are extrinsic Euler angles in XYZ order.

    • 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 Optional[CartesianPose]

from machinelogic import Machine

machine = Machine()
my_robot = machine.get_robot("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 = [
   -267.8,    # x in millimeters
    -89.2,    # y in millimeters
    277.4,    # z in millimeters
   -167.8,    # rx in degrees
        0,    # 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.00,    # rz in degrees
]

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

• Description Moves the robot to a specified Cartesian position asynchronously.

• Parameters

  • target

    • Description The end effector's pose, in mm and degrees, where the angles are extrinsic Euler angles in XYZ order.

    • 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 Optional[CartesianPose]

from machinelogic import Machine

machine = Machine()
my_robot = machine.get_robot("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 = [
   -267.8,    # x in millimeters
    -89.2,    # y in millimeters
    277.4,    # z in millimeters
   -167.8,    # rx in degrees
        0,    # 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.00,    # rz in degrees
]

my_robot.movel_async(
    cartesian_pose,
    linear_velocity,  # Optional
    linear_acceleration,  # Optional
    reference_frame,  # Optional
)
print("Robot is moving asynchronously to the specified Cartesian pose.")
my_robot.wait_for_motion_completion()
print("Robot has finished moving to the specified Cartesian pose.")

• 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[[IRobotAlarm], None]

• Returns

  • Description The callback ID.

  • Type int

from machinelogic import Machine

machine = Machine()
my_robot = machine.get_robot("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)


my_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()
my_robot = machine.get_robot("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 = my_robot.on_system_state_change(handle_state_change)
print(callback_id)

• Description It will disconnect then reconnect the MachineMotion to the robot.

• Parameters

  • timeout

    • Description The timeout in seconds, after which an exception will be thrown, default is 15 seconds.

    • Type Union[float, None]

• Returns

  • Description True if successful.

  • Type bool

from machinelogic import Machine

machine = Machine()
my_robot = machine.get_robot("Robot")

# if no timeout argument is provided, the default timeout is 15 seconds
did_reconnect = my_robot.reconnect()
print(did_reconnect)

• Description Attempts to reset the robot to a normal operational state.

• Returns

  • Description True if successful.

  • Type bool

from machinelogic import Machine

machine = Machine()
my_robot = machine.get_robot("Robot")

did_reset = my_robot.reset()
print(did_reset)

# Robot state should be 'Normal'
print(my_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()
my_robot = machine.get_robot("Robot")

# Weight in Kilograms
weight = 2.76
is_successful = my_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()
my_robot = machine.get_robot("Robot")

# This offset will be applied in reference
# to the end effector coordinate system
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.00,   # rz degrees
]

is_successful = my_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
my_robot = machine.get_robot("Robot")

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

• 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 TeachModeContextManager

import time

from machinelogic import Machine

machine = Machine()
my_robot = machine.get_robot("Robot")

with my_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(my_robot.state.operational_state)
    time.sleep(1)

time.sleep(1)

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

• Description Waits for the robot to complete its current motion. Used in asynchronous movements.

• Parameters

  • timeout

    • Description The timeout in seconds, after which an exception will be thrown.

    • Type Optional[float]

• Returns

  • Description True if successful.

  • Type bool

• Raises

  • Type RobotException

  • Description If the request fails or the move did not complete in the allocated amount of time.

from machinelogic import Machine

machine = Machine()
my_robot = machine.get_robot("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
]

my_robot.movej_async(
  joint_angles,
  joint_velocity,
  joint_acceleration,
)
print("Robot is moving asynchronously to the specified joint angles.")
my_robot.wait_for_motion_completion()
print("Robot has finished moving to the specified joint angles.")

• Description (Deprecated) Use cartesian_position_data instead.

• Type CartesianPose

from machinelogic import Machine

machine = Machine()
my_robot = machine.get_robot("Robot")

 # Note: cartesian_position has been deprecated in favor of cartesian_position_data
end_effector_pose = my_robot.state.cartesian_position
end_effector_position_mm = end_effector_pose[:3]
end_effector_orientation_euler_xyz_deg = end_effector_pose[-3:]
print(f"End effector's pose: {end_effector_pose}")
print(f"End effector's Cartesian position: {end_effector_position_mm}")
print(f"End effector's Euler XYZ orientation: {end_effector_orientation_euler_xyz_deg}")

• Description          A tuple of the robot current Cartesian position and the timestamp in seconds and milliseconds to epoch.        

• Type tuple[CartesianPose, Timestamp]

from machinelogic import Machine

machine = Machine()
my_robot = machine.get_robot("Robot")

end_effector_pose = my_robot.state.cartesian_position_data[0]
timestamp = my_robot.state.cartesian_position_data[1]

end_effector_position_mm = end_effector_pose[:3]
end_effector_orientation_euler_xyz_deg = end_effector_pose[-3:]

print(f"End effector's pose: {end_effector_pose}")
print(f"End effector's Cartesian position: {end_effector_position_mm}")
print(f"End effector's Euler XYZ orientation: {end_effector_orientation_euler_xyz_deg}")

print(f"Timestamp: {timestamp}")

• Description (Deprecated) Use joint_angles_data instead.

• Type JointAnglesDegrees

from machinelogic import Machine

machine = Machine()
my_robot = machine.get_robot("Robot")

 # Note: joint_angles has been deprecated in favor of joint_angles_data
print(my_robot.state.joint_angles)

• Description          A tuple of the robot current joint angles and the timestamp in seconds and milliseconds to epoch.        

• Type tuple[JointAnglesDegrees, Timestamp]

from machinelogic import Machine

machine = Machine()
my_robot = machine.get_robot("Robot")

joint_angles = my_robot.state.joint_angles_data[0]
timestamp = my_robot.state.joint_angles_data[1]

print(f"Joint angles: {joint_angles}")
print(f"Timestamp: {timestamp}")

• Description Check if the robot is currently moving.

• Type bool

from machinelogic import Machine

machine = Machine()
my_robot = machine.get_robot("Robot")
print(my_robot.state.move_in_progress)

• Description The current robot operational state.

• Type RobotOperationalState

from machinelogic import Machine

machine = Machine()
my_robot = machine.get_robot("Robot")
print(my_robot.state.operational_state)

• Description The current robot safety state.

• Type RobotSafetyState

from machinelogic import Machine

machine = Machine()
my_robot = machine.get_robot("Robot")
print(my_robot.state.safety_state)

• Description The tool center point (TCP) offset, in mm and degrees, where the angles are extrinsic Euler angles in XYZ order.

• Type CartesianPose

• 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()
my_robot = machine.get_robot("Robot")
print(my_robot.state.get_digital_input_value(0))

Description: The robot's operational state.

• OFFLINE= 0

• NON_OPERATIONAL= 1

• FREEDRIVE= 2

• NORMAL= 3

• UNKNOWN= 4

• NEED_MANUAL_INTERVENTION= 5

Description: The robot's safety state.

• NORMAL= 0

• EMERGENCY_STOP= 2

• REDUCED_SPEED= 3

• SAFEGUARD_STOP= 4

• UNKNOWN= 5

• Description The address of the ROS-container or the robot.

• Type str

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

• Type MillimetersPerSecond | None

from machinelogic import Machine

machine = Machine()
my_robot = machine.get_robot("Robot")
print(my_robot.configuration.cartesian_velocity_limit)

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

• Type DegreesPerSecond | None

from machinelogic import Machine

machine = Machine()
my_robot = machine.get_robot("Robot")
print(my_robot.configuration.joint_velocity_limit)

• Description The friendly name of the robot.

• Type str

from machinelogic import Machine

machine = Machine()
my_robot = machine.get_robot("Robot")
print(my_robot.configuration.name)

• Description The robot's type.

• Type str

from machinelogic import Machine

machine = Machine()
my_robot = machine.get_robot("Robot")
print(my_robot.configuration.robot_type)

• Description The robot's ID.

• Type str

from machinelogic import Machine

machine = Machine()
my_robot = machine.get_robot("Robot")
print(my_robot.configuration.uuid)

• Description The 1-based index of the robot joint

• Type int

• Description The angle of the joint in degrees

• Type float

• Description The tolerance above the position in degrees

• Type float

• Description The tolerance below the position in degrees

• Type float

• Description A weighting factor for this constraint         (denotes relative importance to other constraints, closer to zero means less important).        

• Type float

• Description Append a movej to the sequence.

• Parameters

  • target

    • Description The target joint angles, in degrees.

    • Type JointAnglesDegrees

  • velocity

    • Description The velocity of the move, in degrees per second. Defaults to 10.0.

    • Type DegreesPerSecond

  • acceleration

    • Description The acceleration of the move, in degrees per second squared. Defaults to 10.0.

    • Type DegreesPerSecondSquared

  • blend_radius

    • Description The blend radius of the move, in millimeters. Defaults to 0.0.

    • Type Millimeters

• 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. Defaults to 100.0.

    • Type MillimetersPerSecond

  • acceleration

    • Description The acceleration of the move, in millimeters per second squared. Defaults to 100.0.

    • Type MillimetersPerSecondSquared

  • blend_radius

    • Description The blend radius of the move, in millimeters. Defaults to 0.0.

    • Type Millimeters

  • reference_frame

    • Description The reference frame for the target pose. Defaults to None.

    • Type CartesianPose

• Returns

  • Description The builder.

  • Type SequenceBuilder

• Description          The configuration of the DigitalInput.        

• Type DigitalInputConfiguration

• Description          The state of the DigitalInput.        

• Type DigitalInputState

from machinelogic import Machine

machine = Machine()

my_input = machine.get_input("Input")

if my_input.state.value:
    print(f"{my_input.configuration.name} is HIGH")
else:
    print(f"{my_input.configuration.name} is LOW")

• Description          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.        

• Type bool

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

• Type bool

• Description The MachineMotion controller id of the DigitalInput/DigitalOutput.

• Type str

• Description The MachineMotion controller port of the DigitalInput/DigitalOutput.

• Type int

• Description The device number of the DigitalInput/DigitalOutput.

• Type int

• Description The name of the DigitalInput/DigitalOutput.

• Type str

• Description The pin number of the DigitalInput/DigitalOutput.

• Type int

• Description The unique ID of the DigitalInput/DigitalOutput.

• Type str

• Description          The configuration of the Output.        

• Type DigitalOutputConfiguration

• 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 Machine, MachineException, DigitalOutputException

machine = Machine()
my_output = machine.get_output("Output")

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

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

• Type bool

• Description The MachineMotion controller id of the DigitalInput/DigitalOutput.

• Type str

• Description The MachineMotion controller port of the DigitalInput/DigitalOutput.

• Type int

• Description The device number of the DigitalInput/DigitalOutput.

• Type int

• Description The name of the DigitalInput/DigitalOutput.

• Type str

• Description The pin number of the DigitalInput/DigitalOutput.

• Type int

• Description The unique ID of the DigitalInput/DigitalOutput.

• Type str

• Description          The configuration of the actuator.        

• Type PneumaticConfiguration

• Description          The state of the actuator.        

• Type typing.Literal['pushed', 'pulled', 'transition', 'unknown']

• 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 The MachineMotion controller id.

• Type str

• Description The MachineMotion controller port of the io module that controls the pneumatic axis.

• Type int

• Description The device id of the io module that controls the pneumatic axis.

• Type int

• Description The optional pull in pin.

• Type typing.Optional[int]

• Description The optional push in pin.

• Type typing.Optional[int]

• Description The name of the Pneumatic.

• Type str

• Description The pull out pin of the axis.

• Type int

• Description The push out pin of the axis.

• Type int

• Description The ID of the Pneumatic.

• Type str

• Description          The configuration of the ACMotor.        

• Type ACMotorConfiguration

• Description Begins moving the AC Motor forward.

• Raises

  • Type ACMotorException

  • Description If the move was unsuccessful.

from time import sleep
from machinelogic import Machine

machine = Machine()
my_ac_motor = machine.get_ac_motor("AC Motor")

my_ac_motor.move_forward()
sleep(10)
my_ac_motor.stop()

• Description Begins moving the AC Motor in reverse.

• Raises

  • Type ACMotorException

  • Description If the move was unsuccessful.

import time
from machinelogic import Machine

machine = Machine()
my_ac_motor = machine.get_ac_motor("AC Motor")

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

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

• Description Stops the movement of the AC Motor.

• Raises

  • Type ACMotorException

  • Description If the stop was unsuccessful.

import time
from machinelogic import Machine

machine = Machine()

my_ac_motor = machine.get_ac_motor("AC Motor")

# Move the AC Motor forwards
my_ac_motor.move_forward()

# Do something here
time.sleep(10)

my_ac_motor.stop()

• Description The MachineMotion controller id

• Type str

• Description The MachineMotion controller port of the io module that controls the ac_motor.

• Type int

• Description The device id of the io module of the ac_motor.

• Type int

• Description The name of the Pneumatic.

• Type str

• Description The push out pin of the axis.

• Type int

• Description The pull out pin of the axis.

• Type int

• Description The ID of the Pneumatic.

• Type str

• Description Current state of the path follower

• Type PathFollowerState

• Description Add a tool to be referenced by the M(3-5) $[tool_id] commands

• Parameters

  • tool_id

    • Description Unique integer defining tool id.

    • Type int

  • m3_output

    • Description Output to map to the M3 Gcode command

    • Type DigitalOutput

  • m4_output

    • Description Optional, Output to map to the M4 Gcode command

    • Type Union[IDigitalOutput, None]

• Raises

  • Type PathFollowerException

  • Description If the tool was not properly added.

from machinelogic import Machine, PathFollower

machine = Machine()
x_axis = machine.get_actuator("X_Actuator")
y_axis = machine.get_actuator("Y_Actuator")
m3_output = machine.get_output("M3_Output")
m4_output = machine.get_output("M4_Output")

GCODE = """
G90   ; Absolute position mode
G0 X60 Y110 F1200 ; Rapid move at 1200 mm/minute
M3 $1 ; Start tool 1 in clockwise direction
G1 X110 Y110 F1000 ; Travel move at 1000 mm/minute
M4 $1 ; counter clockwise now
G0 X50 Y50
M5 $1 ; Stop tool 1
G0 X1 Y1
"""

# Create PathFollower instance
path_follower = PathFollower(x_axis, y_axis)

# Associate a digital output with a GCode tool number
path_follower.add_tool(1, m3_output, m4_output)  # clockwise  # counterclockwise

path_follower.start_path(GCODE)

• Description Start the path, returns when path is complete

• Parameters

  • gcode

    • Description Gcode path

    • Type str

• Raises

  • Type PathFollowerException

  • Description If failed to run start_path

from machinelogic import Machine, PathFollower

machine = Machine()

# must be defined in ControlCenter
x_axis = machine.get_actuator("X_Actuator")
y_axis = machine.get_actuator("Y_Actuator")

GCODE = """
(Operational mode commands)
G90   ; Absolute position mode
G90.1 ; Absolute arc centre
G21   ; Use millimeter units
G17   ; XY plane arcs
G64 P0.5 ; Blend move mode, 0.5 mm tolerance
(Movement and output commands)
G0 X60 Y110 F1200 ; Rapid move at 1200 mm/minute
G1 X110 Y110 F1000 ; Travel move at 1000 mm/minute
G2 X110 Y10 I100 J60 ; Clockwise arc
G1 X60 Y10
G2 X60 Y110 I60 J60
G4 P1.0 ; Dwell for 1 second
G0 X1 Y1
"""

# Create PathFollower instance
path_follower = PathFollower(x_axis, y_axis)

# Run your Gcode
path_follower.start_path(GCODE)

• Description Start the path, nonblocking, returns immediately

• Parameters

  • gcode

    • Description Gcode path

    • Type str

• Raises

  • Type PathFollowerException

  • Description If failed to run start_path_async

from machinelogic import Machine, PathFollower
import time

machine = Machine()

# must be defined in ControlCenter
x_axis = machine.get_actuator("X_Actuator")
y_axis = machine.get_actuator("Y_Actuator")

GCODE = """
(Operational mode commands)
G90   ; Absolute position mode
G90.1 ; Absolute arc centre
G21   ; Use millimeter units
G17   ; XY plane arcs
G64 P0.5 ; Blend move mode, 0.5 mm tolerance
(Movement and output commands)
G0 X60 Y110 F1200 ; Rapid move at 1200 mm/minute
G1 X110 Y110 F1000 ; Travel move at 1000 mm/minute
G2 X110 Y10 I100 J60 ; Clockwise arc
G1 X60 Y10
G2 X60 Y110 I60 J60
G4 P1.0 ; Dwell for 1 second
G0 X1 Y1
"""

path_follower = PathFollower(x_axis, y_axis)

# Run your Gcode
path_follower.start_path_async(GCODE)

PATH_IN_PROGRESS = True
while PATH_IN_PROGRESS:
    time.sleep(0.5)
    path_state = path_follower.state
    PATH_IN_PROGRESS = path_state.running
    print(
        {
            "running": path_state.running,
            "line_number": path_state.line_number,
            "current_command": path_state.current_command,
            "error": path_state.error,
            "speed": path_state.speed,
            "acceleration": path_state.acceleration,
        }
    )

• Description Abruptly stop the path following procedure.

• Raises

  • Type PathFollowerException

  • Description If failed to stop path

• Description Wait for the path to complete

from machinelogic import Machine, PathFollower

machine = Machine()

# must be defined in ControlCenter
x_axis = machine.get_actuator("X_Actuator")
y_axis = machine.get_actuator("Y_Actuator")

GCODE = """
(Operational mode commands)
G90   ; Absolute position mode
G90.1 ; Absolute arc centre
G21   ; Use millimeter units
G17   ; XY plane arcs
G64 P0.5 ; Blend move mode, 0.5 mm tolerance
(Movement and output commands)
G0 X60 Y110 F1200 ; Rapid move at 1200 mm/minute
G1 X110 Y110 F1000 ; Travel move at 1000 mm/minute
G2 X110 Y10 I100 J60 ; Clockwise arc
G1 X60 Y10
G2 X60 Y110 I60 J60
G4 P1.0 ; Dwell for 1 second
G0 X1 Y1
"""

# Create PathFollower instance
path_follower = PathFollower(x_axis, y_axis)

# Run your Gcode asynchronously
path_follower.start_path_async(GCODE)

# Waits for path completion before continuing with program
path_follower.wait_for_path_completion()
print("Path Complete")

• Description The current tool acceleration in millimeters/second^2

• Type float

• Description          In-progress command of gcode script.        

• Type typing.Optional[str]

• Description          A description of errors encountered during path execution.        

• Type typing.Optional[str]

• Description          Current line number in gcode script.        

• Type int

• Description          True if path following in progress.        

• Type bool

• Description The current tool speed in millimeters/second

• Type float

• Description Gets a calibration frame from scene assets by name

• Parameters

  • name

    • Description Friendly name of the calibration frame asset

    • Type str

• Returns

  • Description The found calibration frame

  • Type CalibrationFrame

• Raises

  • Type SceneException

  • Description If the scene asset is not found

from machinelogic import Machine

machine = Machine()
scene = machine.get_scene()

# Assuming we have a calibration frame defined
# in Scene Assets called "calibration_frame_1"
calibration_frame = scene.get_calibration_frame("calibration_frame_1")

default_value = calibration_frame.get_default_value()

print(default_value)

• Description Gets the calibration frame's calibrated values.

• Returns

  • Description The calibrated value of the calibration frame in mm and degrees, where the angles are extrinsic Euler angles in XYZ order.

  • Type CartesianPose

• Raises

  • Type SceneException

  • Description If failed to get the calibrated value

from machinelogic import Machine

machine = Machine()
scene = machine.get_scene()

# Assuming we have a calibration frame defined
# in Scene Assets called "calibration_frame_1"
calibration_frame = scene.get_calibration_frame("calibration_frame_1")

calibrated_value = calibration_frame.get_calibrated_value()

print(calibrated_value)

• Description Gets the calibration frame's default values.

• Returns

  • Description The nominal value of the calibration frame in mm and degrees, where the angles are extrinsic Euler angles in XYZ order.

  • Type CartesianPose

• Raises

  • Type SceneException

  • Description If failed to get the default value

from machinelogic import Machine

machine = Machine()
scene = machine.get_scene()

# Assuming we have a calibration frame defined
# in Scene Assets called "calibration_frame_1"
calibration_frame = scene.get_calibration_frame("calibration_frame_1")

default_value = calibration_frame.get_default_value()

print(default_value)

• Description Sets the calibration frame's calibrated values.

• Parameters

  • frame

    • Description The calibrated values of the Calibration Frame in mm and degrees, where the angles are extrinsic Euler angles in XYZ order.

    • Type CartesionPose

• Raises

  • Type SceneException

  • Description If failed to set the calibrated value

from machinelogic import Machine

machine = Machine()
scene = machine.get_scene()

# Assuming we have a calibration frame defined
# in Scene Assets called "calibration_frame_1"
calibration_frame = scene.get_calibration_frame("calibration_frame_1")

# CartesianPose in mm and degrees, where the angles are
# extrinsic Euler angles in XYZ order.
calibrated_cartesian_pose = [100, 100, 50, 90, 90, 0]

calibration_frame.set_calibrated_value(calibrated_cartesian_pose)

• Description Exception.with_traceback(tb) --

• Description Exception.with_traceback(tb) --

• Description Exception.with_traceback(tb) --

• Description Exception.with_traceback(tb) --

• Description Exception.with_traceback(tb) --

• Description Exception.with_traceback(tb) --

• Description Exception.with_traceback(tb) --

• Description Exception.with_traceback(tb) --