Skip to content

ABB and Rapid Robotics

Portfolio

Industrial Robot Arm

In this video, this robot was programmed to in the language RAPID. It interfaces with a COGNEX camera mounted above the platform that feeds the coordinates of the cards in the workspace. The robot then stacks two blocks on each other, the second being a little offset.

The ABB industrial robot arm equipped with the Rapid programming language is a highly efficient and precise solution for automating tasks, such as stacking metal blocks. By employing programming instead of manual control, this robot demonstrates remarkable precision and speed in executing its designated tasks.

Using Rapid as its programming language, the ABB robot arm can be easily programmed to stack three metal blocks. Rapid is a high-level, user-friendly language specifically designed for industrial robots, allowing operators to create complex robotic applications quickly and effectively.

By programming the robot arm to perform the stacking task, several advantages arise. Firstly, precision is significantly improved. The robot can precisely position and align each metal block with utmost accuracy, ensuring that they are stacked perfectly and securely. This level of precision is challenging to achieve consistently when relying on manual control, as human factors and variations may affect the outcome.

Secondly, programming enables the robot arm to execute the task with impressive speed. Once the sequence is programmed, the robot can swiftly perform the stacking operation repeatedly, maintaining consistent productivity without fatigue or human limitations. This not only enhances efficiency but also contributes to increased overall output.

Moreover, programming the robot arm offers flexibility and adaptability. The same robot arm can be reprogrammed to perform various tasks, including stacking different types of objects or even executing entirely different operations altogether. This versatility allows for efficient utilization of the robotic system in diverse industrial environments, reducing the need for specialized equipment or significant reconfiguration.

In conclusion, the ABB industrial robot arm utilizing the Rapid programming language demonstrates exceptional precision and speed when programmed to stack three metal blocks. By leveraging programming, the robot ensures consistent and accurate results, surpassing the limitations of manual control. Its ability to automate tasks with precision and speed makes it an invaluable asset in modern industrial settings, enhancing productivity and enabling flexible operations.

This robot was programmed to do palletization in the language RAPID. It will continue the sequence until it senses that there are no longer blocks that are to be collected from the loading tray. Below is the code that was used.

PROC main()
    ! Define constants
    CONST num_levels = 2
    CONST num_columns = 3
    CONST num_rows = 3
    CONST workpiece_size = 10 ! in millimeters
    CONST column_spacing = 20 ! in millimeters
 
    ! Define targets
    VAR robtarget approach_point := [0, 0, 100, 0, 0, 0]
    VAR robtarget retraction_point := [0, 0, 200, 0, 0, 0]
    VAR robtarget stack_point := [0, 0, 0, 0, 0, 0]
 
    ! Define relative offsets
    VAR robtarget offset := [0, 0, 0, 0, 0, 0]
    offset.x := workpiece_size + column_spacing
    offset.y := workpiece_size + column_spacing
 
    ! Define state machine
    VAR state state_idle := state_idle_func
    VAR state state_place_workpiece := state_place_workpiece_func
    VAR state state_retract := state_retract_func
    VAR state state_next_column := state_next_column_func
    VAR state state_next_row := state_next_row_func
    VAR state state_next_level := state_next_level_func
 
    VAR state current_state := state_idle
 
    ! Loop through levels, columns, and rows
    FOR level := 1 TO num_levels DO
        FOR column := 1 TO num_columns DO
            FOR row := 1 TO num_rows DO
                ! Update stack point target based on current level, column, and row
                stack_point := RelTool(stack_point, offset)
                stack_point.z := (level - 1) * (workpiece_size + column_spacing)
 
                ! Execute state machine to place workpiece
                WHILE current_state != state_idle DO
                    current_state()
                ENDWHILE
 
                ! Move to next row
                IF row < num_rows THEN
                    current_state := state_next_row
ELSE
                    ! Move to next column
                    IF column < num_columns THEN
                        current_state := state_next_column
                    ELSE
                        ! Move to next level
                        IF level < num_levels THEN
                            current_state := state_next_level
                        ELSE
                            ! Finished pallet
                            current_state := state_idle
                        ENDIF
                    ENDIF
                ENDIF
            ENDFOR
        ENDFOR
    ENDFOR
ENDPROC
 
! Define state functions
PROC state_idle_func()
    ! Do nothing
ENDPROC
 
PROC state_place_workpiece_func()
    ! Move to approach point
    MoveL approach_point, v1000, z10, tool0
 
    ! Move to stack point
    MoveL stack_point, v1000, z10, tool0
 
    ! Place workpiece
    ! TODO: Add code to actually place workpiece
 
    ! Move to retraction point
    MoveL retraction_point, v1000, z10, tool0
 
    ! Move back to approach point
    MoveL approach_point, v1000, z10, tool0
 
    ! Return to idle state
    current_state := state_idle
ENDPROC
 
PROC state_retract_func()
    ! Move to retraction point
    MoveL retraction_point, v1000, z10, tool0
 
    ! Return to idle state
    current_state := state_idle
ENDPROC
 
PROC state
_next_column_func()
! Move to next column
stack_point := RelTool(stack_point, [-offset.x, 0, 0, 0, 0, 0])
! Return to place workpiece state
current_state := state_place_workpiece
ENDPROC
 
PROC state_next_row_func()
! Move to next row
stack_point := RelTool(stack_point, [0, -offset.y, 0, 0, 0, 0])
! Return to place workpiece state
current_state := state_place_workpiece
ENDPROC
 
PROC state_next_level_func()
! Move to next level
stack_point := RelTool(stack_point, [0, 0, -(workpiece_size + column_spacing), 0, 0, 0])
! Return to place workpiece state
current_state := state_place_workpiece
ENDPROC
en_USEnglish