rapid_code_python_sample_app_tests.py

 
 
 
import sys
 
from pathlib import Path
 
import ctypes
import time
import os
import sys
import importlib.util
import RapidCodeHelpers as helpers # The check_errors() and check_errors() helpers provided on our API SampleApp documentation pages
 
rapidcode_dir = helpers.find_rapid_code_directory()
 
#Import the INtime licensing dlls
os.add_dll_directory("c:\\Program Files (x86)\\INtime\\bin")
 
#Import the RapidCode.py file (Path to your rapidcode install directory)
sys.path.append(str(rapidcode_dir))
 
import RapidCode # The RapidCode.py wrapper located in your RMP install directory
 
import unittest
import HelloRapidCode
 
class Testing(unittest.TestCase):
    motioncontroller:RapidCode.Axis =RapidCode.MotionController.CreateFromSoftware(str(rapidcode_dir))
    helpers.check_errors(motioncontroller)
 
    axis0:RapidCode.Axis = motioncontroller.AxisGet(0)
    axis1:RapidCode.Axis = motioncontroller.AxisGet(1)
    axis2:RapidCode.Axis = motioncontroller.AxisGet(2)
    axis3:RapidCode.Axis = motioncontroller.AxisGet(3)
    axis4:RapidCode.Axis = motioncontroller.AxisGet(4)
    axis5:RapidCode.Axis = motioncontroller.AxisGet(5)
    joints:RapidCode.MultiAxis=motioncontroller.MultiAxisGet(6)
    #HelperFunctions.check_errors(axis0)
    axis=axis0
 
    @classmethod
    def tearDownClass(self):
        print("TEAR DOWN THE WHOLE THING")
        print("motioncontroller.Delete()")
        self.motioncontroller.Delete()
        print("motioncontroller.Delete() DONE")
 
    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):
        INPUT_INDEX = 0
        OUTPUT_INDEX = 1
 
        user_buffer_address = self.motioncontroller.AddressGet(RapidCode.RSIControllerAddressType_RSIControllerAddressTypeUSER_BUFFER, 0)
 
        input0 = RapidCode.IOPoint.CreateDigitalInput( self.motioncontroller, user_buffer_address, INPUT_INDEX)
        output0 = RapidCode.IOPoint.CreateDigitalOutput( self.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"
        self.motioncontroller.MemorySet(input0.AddressGet(), 0)
        assert not input0.Get(), "The getter function should return a value equal to false"
        self.motioncontroller.MemorySet(input0.AddressGet(), 1)
        assert input0.Get(), "The getter function should return a value equal to true"
    
 
    # 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()