rapid_code_python_sample_app_tests.py

 
 
 
import sys
 
from pathlib import Path
 
import ctypes
import time
import os
import platform
import sys
import importlib.util
 
if platform.system() == "Windows":
    # On Windows, we expect RMP to be in a relative path to the current working directory
    # so we use the helpers to find it
    import RapidCodeHelpers as helpers
    rapidcode_dir = helpers.find_rapid_code_directory()
    sys.path.append(rapidcode_dir)
 
    #Import the ntx.dll from INtime
    os.add_dll_directory("c:\\Program Files (x86)\\INtime\\bin") #ntx.dll
else:
    # On Linux, we expect RMP to be in an absolute path, so we use it directly
    rapidcode_dir = "/rsi"
    sys.path.append(rapidcode_dir)
    sys.path.append("/rsi/examples/Python")
    import RapidCodeHelpers as helpers
 
import RapidCodePython as RapidCode # The RapidCodePython.py wrapper located in your RMP install directory
 
import unittest
import HelloRapidCode
 
class Testing(unittest.TestCase):
    def test_hello(self):
        HelloRapidCode.main()
 
    # def test_gearing(self):
    #     POSITION=1
    #     VELOCITY=1
    #     ACCELERATION=2
    #     DECELERATION=2
    #     JERK_PERCENT=.5
    #     numerator = 2   # Specify the numerator of the gearing ratio.
    #     denominator = 1 # Specify the denominator of the gearing ratio.
    #     self.axis1.ClearFaults()
    #     self.axis1.AmpEnableSet(True)
    #     self.axis0.ClearFaults()
    #     self.axis0.AmpEnableSet(True)
    #     # Configure the 'follower' axis to be a follow to the 'moving' axis at a ratio of 2:1, that is,
    #     # for every rotation of the Moving Axis axis, the Driven axis will rotate twice.
    #     self.axis1.GearingEnable(self.axis0,
    #                                 RapidCode.RSIAxisMasterType_RSIAxisMasterTypeAXIS_COMMAND_POSITION, # If NOT using a Phantom Axis, switch to RSIAxisMasterTypeAXIS_ACTUAL_POSITION
    #                                 numerator,
    #                                 denominator)
 
    #     # Perform a S-curve motion on the Moving Axis axis.
    #     self.axis0.MoveSCurve(POSITION,
    #                             VELOCITY,
    #                             ACCELERATION,
    #                             DECELERATION,
    #                             JERK_PERCENT)
 
    #     self.axis0.MotionDoneWait() # Wait for motion to finish.
 
    #     # Test assert
    #     self.assertEqual(self.axis0.CommandPositionGet(), POSITION, "The command position should be equal to POSITION")
    #     self.assertEqual(self.axis1.CommandPositionGet(), POSITION * (numerator / denominator), "The command position should be equal to twice POSITION")
 
 
    # def test_s_curve_motion(self):
 
    #     # See axis config to learn how to set those values.
    #     self.axis.ClearFaults()
    #     self.axis.AmpEnableSet(True)
    #     self.axis.MoveSCurve(2,1000,100,100,50)
    #     # Wait for motion to finish
    #     self.axis.MotionDoneWait(constants.timeout)
        
    #     # Test assert
    #     self.assertEqual(self.axis.CommandPositionGet(), 2, "The command position should be equal to POSITION")
 
    
    def test_iopoint(self):
        creation_params:RapidCode.CreationParameters = helpers.get_creation_parameters()
        motioncontroller:RapidCode.MotionController = RapidCode.MotionController.Create(creation_params)
        helpers.check_errors(motioncontroller)
 
 
        INPUT_INDEX = 0
        OUTPUT_INDEX = 1
 
        user_buffer_address = motioncontroller.AddressGet(RapidCode.RSIControllerAddressType_RSIControllerAddressTypeUSER_BUFFER, 0)
 
        input0 = RapidCode.IOPoint.CreateDigitalInput( motioncontroller, user_buffer_address, INPUT_INDEX)
        output0 = RapidCode.IOPoint.CreateDigitalOutput( motioncontroller, user_buffer_address, OUTPUT_INDEX)
 
        output0.Set(False)
        assert not output0.Get(), "The getter function should return a value equal to false"
        output0.Set(True)
        assert output0.Get(), "The getter function should return a value equal to true"
        motioncontroller.MemorySet(input0.AddressGet(), 0)
        assert not input0.Get(), "The getter function should return a value equal to false"
        motioncontroller.MemorySet(input0.AddressGet(), 1)
        assert input0.Get(), "The getter function should return a value equal to true"
 
        motioncontroller.Delete()
    
 
    # def test_custom_robot_types(self):
 
    #     # The joint index of each axis is the index within the MultiAxis object.
    #     # "X-Axis" has joint index 0
    #     # "Y-Axis" has joint index 1
    #     # "Z-Axis" has joint index 2
    #     # "A-Axis" has joint index 3
    #     # "B-Axis" has joint index 4
    #     # "C-Axis" has joint index 5
    #     axes = [self.axis0, self.axis1, self.axis2, self.axis3, self.axis4, self.axis5]
    #     self.joints.AxesAdd(axes, len(axes))
    #     self.joints.ClearFaults()
 
    #     units = RapidCode.LinearUnits.Meters
    #     modelName = "RSI_XYZABC_Meters"
    #     scaling = 1.0
    #     offset = 0.0
    #     builder = RapidCode.LinearModelBuilder(modelName)
    #     builder.UnitsSet(units)
    #     builder.JointAdd(RapidCode.LinearJointMapping(0, RapidCode.CartesianAxis.X)    ) #{ ExpectedLabel = xLabel, Scaling = scaling, Offset = offset })
    #     builder.JointAdd(RapidCode.LinearJointMapping(1, RapidCode.CartesianAxis.Y) )  #  { ExpectedLabel = yLabel, Scaling = scaling, Offset = offset })
    #     builder.JointAdd(RapidCode.LinearJointMapping(2, RapidCode.CartesianAxis.Z)   ) # { ExpectedLabel = zLabel, Scaling = scaling, Offset = offset })
    #     builder.JointAdd(RapidCode.LinearJointMapping(3, RapidCode.CartesianAxis.Roll) )# { ExpectedLabel = aLabel, Scaling = scaling, Offset = offset })
    #     builder.JointAdd(RapidCode.LinearJointMapping(4, RapidCode.CartesianAxis.Pitch) )#{ ExpectedLabel = bLabel, Scaling = scaling, Offset = offset })
    #     builder.JointAdd(RapidCode.LinearJointMapping(5, RapidCode.CartesianAxis.Yaw)  )# { ExpectedLabel = cLabel, Scaling = scaling, Offset = offset })
 
    #     # Create a Robot object with a multi axis containing all joints and the kinematic type
    #     motionFrameBufferSize = 50 # This is the minimum valid motion frame buffer size.
    #     robot = RapidCode.Robot.RobotCreate(self.motioncontroller, self.joints, builder, motionFrameBufferSize)
    #     helpers.CheckErrors(robot)
 
    #     robot.PathAccelerationSet(1000)  # UserUnits per sec sqd
    #     robot.PathVelocity
 
 
    
 
if __name__ == '__main__':
    unittest.main()