DEV Community: ZMOTION CONTROLLER

How to Trigger Signals to do Loading & Unloading?

ZMOTION CONTROLLER — Tue, 18 Mar 2025 06:50:49 +0000

Nowadays, for the manufacturing industry, it needs to develop towards the intelligence, like, 3C electronics, PCB, food packaging, medicine, cosmetics and automotive parts, etc., then in these fields, especially for tiny materials, there is no doubt they are undergoing a transformation in production mode.

Like, for loading by traditional mechanical vibration disk / single placing / single labeling, they can’t meet high-precision, high-efficiency, and soft production needs of current market.

In a word, now industry trends to “multi-type & small-bulk customized” production mode from former “single-type with a large amount” mode.

Today, we mainly talk about “vision fly-shooting loading & unloading with multi-nozzle” solution.

Technology Brief Introduction of “Multi-Nozzle” Vision Fly-Shooting Loading & Unloading”

Firstly, put materials in the flexible vibration disk, and spread it out through vibration. Then, roughly recognize, match, and generate OK material coordinates by the third-party vision. At the same time, the machine runs to OK coordinates synchronously, sucking materials through multi-nozzle. Next, in the process of placing material at material disk, it will do vision fly-shooting to achieve position correction. At last, materials are put into material disk.

Sometimes, the loading & unloading system needs to process complex material types, such as, it includes packaging materials with smart labels such as QR codes, barcodes, anti-counterfeiting codes, as well as various types of precision electronic components and micro hardware accessories. Obviously, these kinds of materials need high vision recognition precision, mechanical positioning accuracy, and software flexibility.

common loading & unloading materials

Common Vision Loading & Unloading Traditional Solution

Generally, when picking and placing the material, there will be small position offset by manipulator gripper / suction disk, then causing whole placing precision. In order to avoid this problem, an industrial camera is usually used to capture the position of the material being grabbed or sucked during the movement of the workpiece, and to perform position correction.

If without vision fly-shooting, solution of “IPC + machine vision + PLC + touch screen” is used. And it only can shoot when it stops at fixed position to do position correction, that is, it needs to stop for shooting, then moves again after shot. In this way, waiting time is more obviously, which not only reduces loading & unloading technology efficiency, also affects the capacity.

device V/T of traditional fixed position shooting

Zmotion Technology Multi-Nozzle Vision Loading & Unloading Solution
According to traditional solution situation, Zmotion develops one super-high-speed PCIe EtherCAT motion control card PCIE464M to do multi-nozzle vision loading & unloading solution.

Specifically, when it moves to preset shooting area, motion control card itself high-speed IO port can precisely trigger the industrial camera to execute multi-position fly-shooting. At the same time, combining with the third-party vision, it can capture graphics parallelly and recognize features for multi-nozzle station in a short time, as well as feedback the real-time pixel level positioning data to motion controller.

Zmotion multi-nozzle fly-shooting loading & unloading solution can complete multi-axis position compensation and angle correction synchronously, high-speed continuous fly-shooting can be achieved, which can promote more 12% comprehensive efficiency than traditional fixed shooting.

device V/T of Zmotion fly-shooting

1. How to Achieve Loading & Unloading?

PCIE464M motion control card sends commands to EtherCAT drives, then motors will execute corresponding motion control tasks. Then, the system will feedback the motor real-time position (MPOS) through encoder / grating ruler. And the precision position control can be realized by our powerful motion control algorithm. During the motion, trigger the camera to shoot at precise target position, even in high-speed motion, image acquisition precision and consistency can be ensured.

Therefore, it can realize precision positioning under high-speed fly-shooting.

(1) Solution Whole Process

(2) Solution Specific Actions

[Step 1: Material Disk Vision Positioning]

The camera takes the picture for materials in vibration disk to do rough positioning, then calculate position coordinates and planning path of capturing through vision.

[Step 2: Loading Capturing]

According to calculated position, motion axis’ suction moves to correct position, then multiple nozzles to suck and capture materials.

[Step 3: Bottom Camera Multi-Position Vision Fly-Shooting]

Captured material moves to shooting area of bottom camera, then, the camera will be triggered by motion control card inner precision output / hardware position comparison output (HW) to do vision fly-shooting.

[Step 4: Multi-Position Positioning & Correction]

Use the third-party vision to do vision analysis for shot graphic, and correct the position.

[Step 5: Unloading & Placing]

While moving to placing position, correct angle and position, after arrived correct position, place materials.

[Step 6: Next Capturing]

When placed, return to loading position and ready to next capture.

2. Why Choose this Loading & Unloading Solution?

a. High Compatibility

It supports all kinds of operation systems, WindowsXP / 7 / 10 / 11, Linux.

b. Easy to Develop

It supports general API function interface, easy and flexible to program.

c. Faster Efficiency

PCIe interface is faster than PCI to transfer data, suit to high-speed & high-precision applications.

There are 12 independent hardware position comparison output, which can achieve fly-shooting at multi-point multi-position, that is, the whole production efficiency can be promoted above 10%.

d . C onvenient Wiring

There are 16 digital inputs and 16 digital outputs, no need of adaptor board.

e. Higher Execution Efficiency

It not only can develop by PC host computer languages (C# / C++ / LabVIEW / Python, etc.), also these languages can be used together with our BASIC language, which promotes command’s real-time execution efficiency.

f. Higher Device Capacity

The motion control card’s EtherCAT synchronous period achieves 125us.

g. Lower Machine CT

In the process of machine vision positioning correction, use fly-shooting technology, which can reduce machine CT.

h. Higher Precision

There is real test that shows the loading & unloading precision can be up to ±0.02mm.

Delta Parallel Robotic Arm by C# | Vision Synchronous Sorting

ZMOTION CONTROLLER — Tue, 18 Feb 2025 07:26:16 +0000

Today, Zmotion shares "how to do synchronous sorting in assemble line through C# for Delta robotic arm".

Also, we combine our "vision motion controller" with C# to achieve that.
"Vision Motion Controller" -- "VPLCXXX" -- "VPLC711"

PART ONE:
Delta Parallel Robotic Arm by C# | How to Do Kinematic and Manual

PART TWO:
Delta Parallel Robotic Arm by C# | How to Do Camera Calibration & Shape Matching

01

How to Add Motion and Vision Libraries for Delta Robotic Arm by C#

Here, use VS2010.

Step 1: Build One Project
--click "File" - "New" - "Project"--
--select "Visual C#", .Net Framework 4 and Windows program--

Step 2: Obtain Zmotion C# Library
--method 1: find corresponding library in Zmotion website "download", then download by yourself--
--method 2: contact us, send the corresponding library to you--

Step 3: Develop by Zmotion C# Library File
Note: the downloaded library is "motion control library", if you need vision function, please obtain vision library from us.

--copy "Zmcaux.cs" (motion library) and "Zvision.cs" (vision library) files into new built project--

--put zauxdll.dll, zmotion.dll, and zvision.dll files into folder of bin\debug--

--open the file, and click "show all files" in the "solution resource manager", and right click "Zmcaux.cs" and "Zvision.cs" files, then click "include in project".

Step 4: Edit
--double click "Form 1" of "Form 1.cs"--
--edit "using cszmcaux" and "using ZVision" at the beginning--
--state controller handle "g_handle"--

0 2

Main PC Commands for Delta

In "PC Function Library Programming Manual”, you can check all encapsulated commands. It can be downloaded here or contact us directly.

Here, it will show Delta Synchronous Sorting related commands.

(1) Connect to Controller -- ZAux_OpenEth

(2) Synchronize -- ZAux_Direct_MoveSync

03

How to Use Basic Command to Check MoveSync

(1) Edit Basic to Test MoveSync Usage

'**************************************************************************************
'if there are one pair of “through-beam photoelectric sensor” fixed at two sides of assemble line to real-time detect the product position on the assemble line.
'how to fill in MOVESYNC command parameters: 
'syncposition: the belt axis position when the object arrived at induction position, it needs to record product position through encoder latching. 
'pos1: the position from following axis 1 origin to photoelectric sensor induction position is fixed for each product.
'**************************************************************************************
GLOBAL CONST BeltAxis=4      'belt axis is axis 4
GLOBAL CONST FollowAxis1=0  'following axis 1 is axis 0
GLOBAL CONST InducPos1=30  'the position from following axis 1 origin to photoelectric sensor induction point
GLOBAL CONST StandbyPos1=50'following axis 1’ standby position
GLOBAL CONST EmptyPos1=400  'following axis 1’s unloading position
'stop all axes
RAPIDSTOP(2)
WAIT IDLE     
'initialize axis parameters of corresponding axes
BASE(FollowAxis1, BeltAxis)
ATYPE = 1,1
UNITS = 1000,1000
SPEED = 50,100
DPOS = 0,0
'trigger SCOPE to capture data waveform
TRIGGER
DELAY(1000)
'following axis moves to standby at first
BASE(FollowAxis1)
MOVEABS(StandbyPos1)
'belt axis starts to move
VMOVE(1)  AXIS(BeltAxis)
'if there is one product detected when belt moved at 200
BASE(FollowAxis1)
Wait UNTIL MPOS(BeltAxis)> 200
MOVESYNC(0, 2000, 200, BeltAxis, InducPos1) 'when the command (following axis accelerates to synchronize) executed, it will synchronize with the product
MOVE_OP(0, ON)                           'synchronized, ON vacuum suction 
MOVESYNC(0, 1000, 200, BeltAxis, InducPos1) 'keep synchronizing 1s
MOVESYNC(-1, 0, 0, -1, EmptyPos1)          'move to unloading position
MOVE_OP(0, OFF)                       'arrive unloading position, off vacuum suction

(2) Check Data Waveform

Obtain corresponding waveform through RTSys (ZDevelop) -- SCOPE, then analyze synchronization process.

According above scope data we can know:

a. when product is detected, the belt position is 200, following axis position is 50.
b. following axis follows with the product, and keeps the same speed, when it synchronized with belt axis, belt position is 400, following axis 1 position is 230.
c. it can be know the product moves forward 200 (400-200) while synchronizing from "a" and "b".
d. the data from following axis 1 origin to photoelectric sensor's sense point position "InducPos1" is 30, so when axis 1 is parallel with belt, belt makes product move forward 200, then now the real distance becomes 230 (200+30).
e. therefore, the result of "d" is consistent with following axis 1 real position after synchronized, that is, assemble synchronous command is OK.

04

One Routine: How C# Do Vision Synchronous Sorting in Assemble Line

(1) Belt Synchronized Command Key Parameters

ZAux_Direct_MoveSync(ZMC_HANDLE handle,float imode,int synctime, float syncposition, int syncaxis, int imaxaxises, int piAxislist, float *pfDisancelist)
*--imode--**
Select synchronized mode.
imode=0+angle: synchronous mode, if belt and axis X are parallel, fill in 0.
imode =-1: end mode, move to the specified absolute position, it is usually used at the unloading position after synchronized and captured the material.

--synctime--
Synchronization time, in ms unit. The movement is completed within the specified time. When completed, axis speed and object speed (on the belt axis) keep same. 0 indicates that the synchronization time is estimated according to motion axis' speed and acceleration.

--syncposition--
When vision or sensor sensed product on the belt, now belt position is MPOS (measurement position).

--pfDistancelist--
If locates the product by vision, this parameter is "world coordinate" of the product when vision recoginized the product.

If it uses photoelectric sensor to detect the product, this parameter is fixed, when the sensor feels the product, product current position absolute coordinate. Now, it can move slave axis manually to positioning the product to get the position.

(2) Vision Synchronous Sorting Steps

A. Codes Details of Vision Matching & Positioning

/************************************************************************************
'Task No.: /
'Function of this function: vision positioning
'Input: /
'Output: / 
'returned value: sub thread – do vision positioning 
**************************************************************************************/
public void RunSubTaskVisua()
{
    int TempArrid = 0;
    float TempVar = 0;
    WriteLog("Vision Function ON");
    while (SysRunFlag > 0)
    {
        //when pause button is not pressed
        while (SysRunFlag == 1) 
        {
            //capture the image
            VisuaOper.CameAcquisition();
            //do template matching
            RTDisplay.Image = VisuaOper.ShapeFind();
            if (MainWindows.BeltMpos != 0)//if gets the belt encoder position normally when capturing the image
            {
                //operate MoveSyncBuff data, please lock at first
                while (true)
                {
                    if (MainWindows.SetMoveSyncFlag == 0)
                    {
                        MainWindows.SetMoveSyncFlag = 1;
                        break;
                    }
                }
                //find array starting subscript that can save data
                int ArrId = 0;
                for (int i = 0; i < 50; i++)
                {
                    if (MainWindows.MoveSyncBuff[i, 0] == 0)
                    {
                        ArrId = i;
                        break;
                    }
                }
                //start to save the data, 10 results can be matched at most
                TempArrid = ArrId;
                for (int i = 0; i < 10; i++)
                {
                    //if the score is OK
                    if (MainWindows.VisionRst[i, 0] >= MainWindows.VisionScore)
                    {
                        int j;
                        //if there is repeated target, delete repeated one
                        for (j = 0; j < TempArrid; j++)
                        {
                            TempVar = MainWindows.VisionRst[i, 1] - MainWindows.BeltMpos - MainWindows.MoveSyncBuff[j, 1] + MainWindows.MoveSyncBuff[j, 4];
                            if (((TempVar) <= 10) && (TempVar >= -10))
                            {
                                j = -10;
                                break;
                            }
                        }
                        if (j >= 0)
                        {
                            MainWindows.MoveSyncBuff[ArrId, 0] = 1;
                            MainWindows.MoveSyncBuff[ArrId, 1] = MainWindows.VisionRst[i, 1];   //save matched X coordinate
                            MainWindows.MoveSyncBuff[ArrId, 2] = MainWindows.VisionRst[i, 2];   //save matched Y coordinate
                            MainWindows.MoveSyncBuff[ArrId, 3] = MainWindows.VisionRst[i, 3];   //save matched angle offset
                            MainWindows.MoveSyncBuff[ArrId, 4] = MainWindows.BeltMpos;       //save belt position when product is matched
                            ArrId = ArrId + 1;
                            IdentiNum.Text = (Convert.ToInt32(IdentiNum.Text) + 1).ToString();
                            WriteLog("Vision Target:" + "(" + MainWindows.VisionRst[i, 1].ToString("0,0") + "," + MainWindows.VisionRst[i, 2].ToString("0,0") + ")");
                        }
                    }
                    //clear scores
                    MainWindows.VisionRst[i, 0] = 0;
                }
                //unlock
                MainWindows.SetMoveSyncFlag = 0;
            }
        }
        Thread.Sleep(100);
    }
}

B. Codes Details of Vision Sorting in Assemble Line

/************************************************************************************
'Task No.: /
'Function of this function: assemble line synchronous sorting
'Input: /
'Output: / 
'returned value: /          
**************************************************************************************/
public void RunSubTaskMotion()
{
    float[] MoveSyncTemp = new float[5];
    float TempMpos = 0;
    while (SysRunFlag > 0)
    {
        while (SysRunFlag == 1)
        {
            if (MainWindows.MoveSyncBuff[0, 0] == 1)
            {
                MainWindows.ZauxErr = zmcaux.ZAux_Direct_GetMpos(MainWindows.g_Handle, MainWindows.ConveyorAxisId, ref TempMpos);
                //if gets the encoder position correctly
                if (0 == MainWindows.ZauxErr) 
                {
                    //how far the encoder moves forward
                    TempMpos = TempMpos - MainWindows.MoveSyncBuff[0, 4];


                    //check whether it is at synchronization starting area
                    if (((MainWindows.MoveSyncBuff[0, 1] + TempMpos) >= MainWindows.SyncReX[0]) && ((MainWindows.MoveSyncBuff[0, 1] + TempMpos) <= MainWindows.SyncReX[1]))
                    {
                        WriteLog("Start to Synchronize to Capture");
                        //get one group of data
                        MoveSyncTemp[0] = MainWindows.MoveSyncBuff[0, 1] ;    //X
                        MoveSyncTemp[1] = MainWindows.MoveSyncBuff[0, 2] ;    //Y  
                        MoveSyncTemp[2] = MainWindows.GetBinHigt;            //capture height
                        MoveSyncTemp[3] = MainWindows.MoveSyncBuff[0, 3];    //Aanle
                        MoveSyncTemp[4] = MainWindows.MoveSyncBuff[0, 4];    //Mpos
                       //send synchronous motion command
                       //0, reset OUT
                        zmcaux.ZAux_Direct_MoveOp(MainWindows.g_Handle, MainWindows.gVAxisList[0], MainWindows.VacSucIo, 0);
                        //1, synchronize with transfer belt at first
                        zmcaux.ZAux_Direct_MoveSync(MainWindows.g_Handle, 0, 0, MainWindows.MoveSyncBuff[0, 4], MainWindows.ConveyorAxisId, 4, MainWindows.gVAxisList, MoveSyncTemp);
                        //2, synchronize a certain time, (there is lag of joint axis) 50ms
                        zmcaux.ZAux_Direct_MoveSync(MainWindows.g_Handle, 0, 50, MainWindows.MoveSyncBuff[0, 4], MainWindows.ConveyorAxisId, 4, MainWindows.gVAxisList, MoveSyncTemp);
                        //3, open vacuum nozzle
                        zmcaux.ZAux_Direct_MoveOp(MainWindows.g_Handle, MainWindows.gVAxisList[0], MainWindows.VacSucIo, 1);
                        //4, synchronize a certain time, 1500ms
                        zmcaux.ZAux_Direct_MoveSync(MainWindows.g_Handle, 0, 700, MainWindows.MoveSyncBuff[0, 4], MainWindows.ConveyorAxisId, 4, MainWindows.gVAxisList, MoveSyncTemp);
                        //5, in synchronization, move axis Z up to safe height, select axis unloading angle
                        MoveSyncTemp[2] = MainWindows.StandPos[2];             //capture height
                        zmcaux.ZAux_Direct_MoveSync(MainWindows.g_Handle, 0, 100, MainWindows.MoveSyncBuff[0, 4], MainWindows.ConveyorAxisId, 4, MainWindows.gVAxisList, MoveSyncTemp);
                        //4, release “synchronize to unloading point”
                        MoveSyncTemp[0] = MainWindows.EmptPos[0];    //X
                        MoveSyncTemp[1] = MainWindows.EmptPos[1];    //Y  
                        MoveSyncTemp[2] = MainWindows.EmptPos[2];    //unloading height
                        MoveSyncTemp[3] = MainWindows.EmptPos[3];    //Aanle
                        zmcaux.ZAux_Direct_MoveSync(MainWindows.g_Handle, -1, 0, 0, -1, 4, MainWindows.gVAxisList, MoveSyncTemp);
                        //5, close vacuum nozzle to place material, delay 100ms
                        zmcaux.ZAux_Direct_MoveOp(MainWindows.g_Handle, MainWindows.gVAxisList[0], MainWindows.VacSucIo, 0);
                        zmcaux.ZAux_Direct_MoveDelay(MainWindows.g_Handle, MainWindows.gVAxisList[0], 100);
                        //6, move to safe height
                        MoveSyncTemp[0] = MainWindows.EmptPos[0];    //X
                        MoveSyncTemp[1] = MainWindows.EmptPos[1];    //Y  
                        MoveSyncTemp[2] = MainWindows.StandPos[2];    //unloading height
                        MoveSyncTemp[3] = MainWindows.EmptPos[3];    //Aanle
                        zmcaux.ZAux_Direct_MoveAbs(MainWindows.g_Handle, 4, MainWindows.gVAxisList, MoveSyncTemp);


                        //operate MoveSyncBuff data, please lock at first
                        while (true)
                        {
                            if (MainWindows.SetMoveSyncFlag == 0)
                            {
                                MainWindows.SetMoveSyncFlag = 1;
                                break;
                            }
                        }
                        //in vision matching buffer, data are covered
                        for (int k = 0; k < 49; k++)
                        {
                            MainWindows.MoveSyncBuff[k, 0] = MainWindows.MoveSyncBuff[k + 1, 0];
                            MainWindows.MoveSyncBuff[k, 1] = MainWindows.MoveSyncBuff[k + 1, 1];
                            MainWindows.MoveSyncBuff[k, 2] = MainWindows.MoveSyncBuff[k + 1, 2];
                            MainWindows.MoveSyncBuff[k, 3] = MainWindows.MoveSyncBuff[k + 1, 3];
                            MainWindows.MoveSyncBuff[k, 4] = MainWindows.MoveSyncBuff[k + 1, 4];
                        }
                        //unlock
                        MainWindows.SetMoveSyncFlag = 0;
                        //until OUT opens
                        int TimeOut = 10000;
                        TimeOut = 100000;
                        //until axis stops
                        int AxisIdle = 0;                 //axis stopped state
                        while (TimeOut > 0)
                        {
                            zmcaux.ZAux_Direct_GetIfIdle(MainWindows.g_Handle, MainWindows.gVAxisList[0], ref AxisIdle);
                            if (AxisIdle == (-1))
                            {
                                break;
                            }
                            Thread.Sleep(10);
                            TimeOut = TimeOut - 10;
                        }
                        if (TimeOut <= 0)
                        {
                            //if timeout, report an error, program stops
                            WriteLog("Timeout Waiting for Axis to Stop ");
                            //Thread.Sleep(100);
                            SysRunFlag = 0;
                            break;
                        }
                        SortNum.Text = (Convert.ToInt32(SortNum.Text) + 1).ToString();
                        WriteLog("Unloading Succeeded ");
                        //exit while, cycle once
                        continue;
                    }
                    else if ((MainWindows.MoveSyncBuff[0, 1] + TempMpos) > MainWindows.SyncReX[1])
                    {
                        //operate MoveSyncBuff data, please lock at first
                        while (true)
                        {
                            if (MainWindows.SetMoveSyncFlag == 0)
                            {
                                MainWindows.SetMoveSyncFlag = 1;
                                break;
                            }
                        }
                        //in vision matching buffer, data are covered
                        for (int k = 0; k < 49; k++)
                        {
                            MainWindows.MoveSyncBuff[k, 0] = MainWindows.MoveSyncBuff[k + 1, 0];
                            MainWindows.MoveSyncBuff[k, 1] = MainWindows.MoveSyncBuff[k + 1, 1];
                            MainWindows.MoveSyncBuff[k, 2] = MainWindows.MoveSyncBuff[k + 1, 2];
                            MainWindows.MoveSyncBuff[k, 3] = MainWindows.MoveSyncBuff[k + 1, 3];
                            MainWindows.MoveSyncBuff[k, 4] = MainWindows.MoveSyncBuff[k + 1, 4];
                        }
                        //unlock
                        MainWindows.SetMoveSyncFlag = 0;
                        //if there is no data in the vision matching buffer area
                        if (MainWindows.MoveSyncBuff[0, 0] == 0)
                        {
                            //Delta moves to standby position
                            zmcaux.ZAux_Direct_MoveAbs(MainWindows.g_Handle, 4, MainWindows.gVAxisList, MainWindows.StandPos);
                            WriteLog("To Standby");
                        }
                    }
                }
            }
            else
            {
                //Delta moves to standby position
                zmcaux.ZAux_Direct_MoveAbs(MainWindows.g_Handle, 4, MainWindows.gVAxisList, MainWindows.StandPos);
            }
            Thread.Sleep(50);
        }
        //stop transfer belt
        zmcaux.ZAux_Direct_Single_Cancel(MainWindows.g_Handle, MainWindows.ConveyorAxisId, 2);
    }
}

Delta Parallel Robotic Arm by C# | How to Do Kinematic and Manual?

ZMOTION CONTROLLER — Thu, 02 Jan 2025 03:28:59 +0000

Here, we take ZMC406R-V2 EtherCAT Motion Controller to build forward or inverse kinematics for Delta through C#. In addition, how to manually control it.

1. How C# Develops Delta Parallel Robotic Arm?

Here, use VS2010.

Step 1: Build One Project
--click "File" - "New" - "Project"--
--select "Visual C#", .Net Framework 4 and Windows program--

Step 2: Obtain Zmotion Library
--method 1: find corresponding library in Zmotion website "download", then download by yourself--
--method 2: contact us, send the corresponding library to you--

Step 3: Develop by Zmotion C# Library File
--copy downloaded C# library file and corresponding file into new built project--
copy "zmcaux.cs" into new built project

copy "zaux.dll" and "zmotion.dll" into bin\debug folder

--open new created file--
*open the file, and click "show all files" in the "solution resource manager", and right click "zmcaux.cs" file, then click "include in project".

--edit--
double click "Form 1" of "Form 1.cs"
edit "using cszmcaux" at the beginning
*state controller handle "g_handle".

2. Main PC Commands for Delta

In "PC Function Library Programming Manual", you can check all encapsulated commands. It can be downloaded here or contact us directly.

Here, it will show Delta related commands.
(1) Connection Command -- ZAux_OpenEth

(2) Forward Connection -- ZAux_Direct_Connreframe

(3) Inverse Connection -- ZAux_Direct_Connframe

(4) Rotate robotic arm coordinate system to get user coordinate system

3. One Routine: How C# Builds Delta Kinematics?

--Theory--

(1) Check Axis Direction
Use Zmotion Delta parallel robotic arm model, the direction of 3 joint axes must be forward when they rotate downside, and the direction of end rotary axis also should be forward when it rotates anticlockwise (looking down).

(2) Save Structural Parameters

Please obtain structural parameters from your robot body manufacturer.

Then write corresponding parameters into our controller TABLE register, next, it can call the interface to build forward or inverse kinematics.

(3) Define Origin

A. when each joint-axis' connection rod L1 is in the horizontal position, it is considered as the joint origin position (generally, robot body will provide positioning pin, if no, it can use "gradienter" to make sure L1 in the horizontal when it is at origin.

B. at this time, axis 0 and axis 1' connection direction is X direction of Cartesian Coordinate System, and system's origin is located at the center of the horizontal plane of connecting rod L1.

(4) Set Joint-Axis & Virtual-Axis

The joint-axis is an actual motor axis. For Delta, it has joint-axis 0, joint-axis 1, joint-axis 2 and end rotation axis. And these joint axes' pulse amounts must be set as needed pulses in one circle (Units = motor pulses in one circle * reduction ratio / 360).

The virtual-axis is a virtual axis for Cartesian Coordinate System, it has system virtual axis X, axis Y, axis Z, and one rotation axis RZ. For X,Y,Z, their UNITS (pulse amount) are recommended as 1000. For RZ, UNITS should be set as needed pulses in one circle.

--Example--

(1) Connect to Controller

Connect to controller, get the handle, then PC uses the obtained handle to control controller.

//connect to controller, default IP is 192.168.0.11
ZauxErr = zmcaux.ZAux_OpenEth("192.168.0.11", out g_Handle);
if (0 != ZauxErr)
{
AlmInifFile.Write(DateTime.Now.ToString("F"), "ZAux_OpenEth Execute Error, Error Code:" + ZauxErr.ToString(), "Error Code Info");
}

(2) Set Delta Parallel Robotic Arm Parameters

(3) Build Forward Kinematic

/************************************************************************************
'Task No.: /
'Function of this function: build robotic arm forward or inverse connection 
'Input: Mode=0—disconnect, 1—inverse connection, 2—forward connection
'Output: /
'Returned Value: 0—success, 1--failure
'Notes: 
‘    *only controller with R is valid    
'    *when in forward, virtual axis MTYPE = 34
‘    *when in inverse, joint axis MTYPE = 34
‘    *when in inverse, keep enable.
**************************************************************************************/
public int ScaraEstab(int Mode)
{
    //update UI interface’s Delta parameters
    ScaraParaWindows.DeltaParaSave();
    //set robotic arm parameters
    SetControPara();
    //save Delta parameters into Ini file
    WriteIniFile();
    //clear controller alarms
    ZauxErr = zmcaux.ZAux_Direct_Single_Datum(g_Handle, 0, 0);
    //update axis list, the axis sequence is J1, J2, Ju, Jz(joint-axis), Vx, Vy, Vr, Vz (virtual-axis)
    int[] mJScaraAxisList = new int[4]; //joint-axis list
    int[] mVScaraAxisList = new int[4]; //virtual-axis list
    for (int i = 0; i < 4; i++)
    {
        mJScaraAxisList[i] = gDeltaAxisList[i];
        mVScaraAxisList[i] = gVAxisList[i];
    }
    //check whether robotic arm parameters are correct
    if ((DeltaR <= 0) || (Deltar <= 0) || (DeltaL1 <= 0) || (DeltaL2 <= 0))
    {
        MessageBox.Show("Delta Robot has Problem, Please Confirm! ");
        return -1;
    }
    //first to save robotic arm structural parameters into controller TABLE register, then it can build robotic arm connection
    //update robotic arm parameters into controller TABLE register
    float[] ScaraParaList = new float[11] { DeltaR, Deltar, DeltaL1, DeltaL2, gMotorPulNum[0] * gReducRatio[0], gMotorPulNum[1] * gReducRatio[1], gMotorPulNum[2] * gReducRatio[2], 0, 0, 0, gMotorPulNum[3] * gReducRatio[3] };
    ZauxErr = zmcaux.ZAux_Direct_SetTable(g_Handle, TableStaraId, 11, ScaraParaList);
    if (0 != ZauxErr)
    {
        return -1;
    }
    if ((1 == Mode) && (0 == ZauxErr)) //build inverse solution for the robot (when the robot parameters are updated successfully)
    {
        //build Scara inverse
        ZauxErr = zmcaux.ZAux_Direct_Connframe(g_Handle, 4, mJScaraAxisList, 14, TableStaraId, 4, mVScaraAxisList);
        if (0 != ZauxErr)
        {
            ProceWindows.WriteLog("Fail to Switch Inverse");
            return -1;
        }
        ProceWindows.WriteLog("Switch to Inverse");
    }
    else if ((2 == Mode) && (0 == ZauxErr)) //build forward solution for the robot (when the robot parameters are updated successfully)
    {
        //build Scara forward
        ZauxErr = zmcaux.ZAux_Direct_Connreframe(g_Handle, 4, mVScaraAxisList, 14, TableStaraId, 4, mJScaraAxisList);
        if (0 != ZauxErr)
        {
            ProceWindows.WriteLog("Fail to Switch Forward");
            return -1;
        }
        ProceWindows.WriteLog("Switch to Forward");
        }
    }
    return 0;
}

Note: for forward, virtual-axis MTYPE will be 34, for inverse, joint-axis MTYPE will be 33. For more, please check former article "EtherCAT Motion Controller in Delta Robotic Arm".

(4) Operate Manual Motion

Below shows routine's manual motion interface.

Press the "Manual" button of "Joint Coordinate System Manual Control", it will automatically build forward connection.

Press the "Manual" button of "Cartesian Coordinate System Manual Control", it will automatically build inverse connection.

When the manual speed decreases to a certain value, it will automatically switch to the inching mode.

A. Joint-Axis Manual Motion

/************************************************************************************
'Task No.: /
'Function of this “function”: joint-axis manual inverse motion, press “-“ to call
'Input: /
'Output: / 
'Returned Value: /
'Note: / 
**************************************************************************************/
private void JHandDirRev0_MouseDown(object sender, MouseEventArgs e)
{
    //whether locks it or not, after locked, then it can move
    int EnableState = 0;
    cszmcaux.zmcaux.ZAux_Direct_GetAxisEnable(MainWindows.g_Handle, MainWindows.gDeltaAxisList[0], ref EnableState);
    //if enabled
    if ((1 == EnableState) || (MainWindows.IsDebug)) 
    {
        int Vmtype = 0;//virtual axis MTYPE
        cszmcaux.zmcaux.ZAux_Direct_GetMtype(MainWindows.g_Handle, MainWindows.gVAxisList[0], ref Vmtype); 
        //if it is not forward state
        if (Vmtype != 34)
        {
            //build robotic arm forward connection
            if (0 != MainWindows.ScaraEstab(2))
            {
                //Fail to build the robot connection
                return;
            }
        }
        //which button to be pressed
        int Id = 0;
        for (int i = 0; i < 4; i++)
        {
            if (((Button)sender).Name == ("JHandDirRev" + i))
            {
                Id = i;
            }
        }
        int TempAxis = 0;
        TempAxis = MainWindows.gDeltaAxisList[Id];
        //if manual speed is less than 5, it is inching mode
        if (5 <= MainWindows.HnadSpeedPerc)
        {
            //set point motion speed
            cszmcaux.zmcaux.ZAux_Direct_SetSpeed(MainWindows.g_Handle, TempAxis, MainWindows.HnadSpeedPerc * MainWindows.gAxisHandSpeed[Id] / 100);
            //send “inverse” motion command
            cszmcaux.zmcaux.ZAux_Direct_Single_Vmove(MainWindows.g_Handle, TempAxis, -1);
        }
        else
        {
            //set inching speed
            cszmcaux.zmcaux.ZAux_Direct_SetSpeed(MainWindows.g_Handle, TempAxis, MainWindows.gAxisHandSpeed[Id] / 10);
            //send inching motion command
            cszmcaux.zmcaux.ZAux_Direct_Single_Move(MainWindows.g_Handle, TempAxis, -1 * MainWindows.HnadSpeedPerc);
        }
    }
}
/************************************************************************************
'Task No.: /
'Function of this “function”: joint-axis manual forward motion, press “+“ to call
'Input: /
'Output: / 
'Returned Value: /
'Note: /     
**************************************************************************************/
private void JHandDirFwd0_MouseDown(object sender, MouseEventArgs e)
{
    //whether locks it or not, after locked, then it can move
    int EnableState = 0;
    cszmcaux.zmcaux.ZAux_Direct_GetAxisEnable(MainWindows.g_Handle, MainWindows.gDeltaAxisList[0], ref EnableState);
    //if enabled
    if ((1 == EnableState) || (MainWindows.IsDebug)) 
    {
        int Vmtype = 0;//virtual axis MTYPE
        cszmcaux.zmcaux.ZAux_Direct_GetMtype(MainWindows.g_Handle, MainWindows.gVAxisList[0], ref Vmtype); 
        //if it is not forward state
        if (Vmtype != 34)
        {
            //build robotic arm forward kinematic
            if (0 != MainWindows.ScaraEstab(2))
            {
                //Fail to build the robot connection
                return;
            }
        }
        //which button to be pressed
        int Id = 0;
        for (int i = 0; i < 4; i++)
        {
            if (((Button)sender).Name == ("JHandDirFwd" + i))
            {
                Id = i;
            }
        }
        int TempAxis = 0;
        TempAxis = MainWindows.gDeltaAxisList[Id];
        //if manual speed is less than 5, it is inching mode
        if (5 <= MainWindows.HnadSpeedPerc)
        {
            //set point motion speed
            cszmcaux.zmcaux.ZAux_Direct_SetSpeed(MainWindows.g_Handle, TempAxis, MainWindows.HnadSpeedPerc * MainWindows.gAxisHandSpeed[Id] / 100);
            //send “forward” motion command
            cszmcaux.zmcaux.ZAux_Direct_Single_Vmove(MainWindows.g_Handle, TempAxis, 1);
        }
        else
        {
            //set inching speed
            cszmcaux.zmcaux.ZAux_Direct_SetSpeed(MainWindows.g_Handle, TempAxis, MainWindows.gAxisHandSpeed[Id] / 10);
            //send inching motion command
            cszmcaux.zmcaux.ZAux_Direct_Single_Move(MainWindows.g_Handle, TempAxis, 1 * MainWindows.HnadSpeedPerc);
        }
    }
}
/************************************************************************************
'Task No.: /
'Function of this “function”: joint-axis stop manual motion, call when point button is released
'Input: /
'Output: / 
'Returned Value: /
'Note: /      
**************************************************************************************/
private void JHandDirRev0_MouseUp(object sender, MouseEventArgs e)
{
    //which button to be pressed
    int Id = 0;
    for (int i = 0; i < 4; i++)
    {
        if (((Button)sender).Name == ("JHandDirRev" + i))
        {
            Id = i;
        }
    }
    int TempAxis = 0;
    TempAxis = MainWindows.gDeltaAxisList[Id];
    //if manual speed is less than 5, it is inching mode
    if (5 <= MainWindows.HnadSpeedPerc)
    {
        MainWindows.ZauxErr = cszmcaux.zmcaux.ZAux_Direct_Single_Cancel(MainWindows.g_Handle, TempAxis, 2);
    }
}

B. Virtual-Axis Manual Motion

/************************************************************************************
'Task No.: /
'Function of this “function”: virtual manual inverse motion, press “-“ to call
'Input: /
'Output: / 
'Returned Value: /
'Note: /     
**************************************************************************************/
private void VHandDirRev0_MouseDown(object sender, MouseEventArgs e)
{
    //whether locks it or not, after locked, then it can move
    int EnableState = 0;
    cszmcaux.zmcaux.ZAux_Direct_GetAxisEnable(MainWindows.g_Handle, MainWindows.gDeltaAxisList[0], ref EnableState);
    //if enabled
    if ((1 == EnableState) || (MainWindows.IsDebug)) 
    {
        int Jmtype = 0;//joint-axis Mtype
        cszmcaux.zmcaux.ZAux_Direct_GetMtype(MainWindows.g_Handle, gDeltaAxisList[0], ref Jmtype);
        //if it is not inverse state
        if (Jmtype != 33)
        {
            //build robotic arm inverse kinematic
            if (0 != MainWindows.ScaraEstab(1))
            {
                //Fail to build the robot connection
                return;
            }
        }
        //which button to be pressed
        int Id = 0;
        for (int i = 0; i < 5; i++)
        {
            if (((Button)sender).Name == ("VHandDirRev" + i))
            {
                Id = i;
            }
        }
        int TempAxis = 0;
        //update current robotic arm state
        TempAxis = MainWindows.gVAxisList[Id];
        //if manual speed is less than 5, it is inching mode
        if (5 <= MainWindows.HnadSpeedPerc)
        {
            //set point motion speed
            cszmcaux.zmcaux.ZAux_Direct_SetSpeed(MainWindows.g_Handle, TempAxis, MainWindows.HnadSpeedPerc * MainWindows.gAxisHandSpeed[Id] / 100);
            //send “inverse” motion command
           cszmcaux.zmcaux.ZAux_Direct_Single_Vmove(MainWindows.g_Handle, TempAxis, -1); 
        }
        else
        {
            //set inching speed
            cszmcaux.zmcaux.ZAux_Direct_SetSpeed(MainWindows.g_Handle, TempAxis, MainWindows.gAxisHandSpeed[Id] / 10);
            //send inching motion command
           cszmcaux.zmcaux.ZAux_Direct_Single_Move(MainWindows.g_Handle, TempAxis, -1 * MainWindows.HnadSpeedPerc);
        }
    }
}
/************************************************************************************
'Task No.: /
'Function of this “function”: joint-axis manual forward motion, press “+“ to call
'Input: /
'Output: / 
'Returned Value: /
'Note: /    
**************************************************************************************/
private void VHandDirFwd0_MouseDown(object sender, MouseEventArgs e)
{
    //whether locks it or not, after locked, then it can move
    int EnableState = 0;
    cszmcaux.zmcaux.ZAux_Direct_GetAxisEnable(MainWindows.g_Handle, MainWindows.gDeltaAxisList[0], ref EnableState);
    //if enabled
    if ((1 == EnableState) || (MainWindows.IsDebug)) 
    {
        int Jmtype = 0;//joint-axis Mtype
        cszmcaux.zmcaux.ZAux_Direct_GetMtype(MainWindows.g_Handle, gDeltaAxisList[0], ref Jmtype);
        //if it is not forward kinematic
        if (Jmtype != 33)
        {
            //build robotic arm forward connection
            if (0 != MainWindows.ScaraEstab(1))
            {
                //Fail to build the robot connection
                return;
            }
        }
        //which button to be pressed
        int Id = 0;
        for (int i = 0; i < 5; i++)
        {
            if (((Button)sender).Name == ("VHandDirFwd" + i))
            {
                Id = i;
            }
        }
        int TempAxis = 0;
        //update current robotic arm state
        TempAxis = MainWindows.gVAxisList[Id];
        //if manual speed is less than 5, it is inching mode
        if (5 <= MainWindows.HnadSpeedPerc)
        {
           //set point motion speed
            cszmcaux.zmcaux.ZAux_Direct_SetSpeed(MainWindows.g_Handle, TempAxis, MainWindows.HnadSpeedPerc * MainWindows.gAxisHandSpeed[Id] / 100);
           //send “forward” motion command
           cszmcaux.zmcaux.ZAux_Direct_Single_Vmove(MainWindows.g_Handle, TempAxis, 1); 
        }
        else
        {
            //set inching speed
            cszmcaux.zmcaux.ZAux_Direct_SetSpeed(MainWindows.g_Handle, TempAxis, MainWindows.gAxisHandSpeed[Id] / 10);
            //send inching motion command
           cszmcaux.zmcaux.ZAux_Direct_Single_Move(MainWindows.g_Handle, TempAxis, 1 * MainWindows.HnadSpeedPerc);
        }
    }
}
/************************************************************************************
'Task No.: /
'Function of this “function”: virtual-axis stop motion, call when the point motion button is released
'Input: /
'Output: / 
'Returned Value: /
'Note: /     
**************************************************************************************/
//stop the motion
private void VHandDirRev0_MouseUp(object sender, MouseEventArgs e)
{
    //which button to be pressed
    int Id = 0;
    for (int i = 0; i < 5; i++)
    {
        if (((Button)sender).Name == ("VHandDirRev" + i))
        {
            Id = i;
        }
    }
    int TempAxis = 0;
    TempAxis = MainWindows.gVAxisList[Id];
    //if manual speed is less than 5, it is inching mode
    if (5 <= MainWindows.HnadSpeedPerc)
    {
        cszmcaux.zmcaux.ZAux_Direct_Single_Cancel(MainWindows.g_Handle, TempAxis, 2);
    }
}

(5) Use Robotic Arm Simulator Tool

Open "ZRobotView" software, enter controller IP (default IP: 192.168.0.11), then click "connect". After connected, click "switch", it can 3D simulate robotic arm operation.

That's all, thank you for your reading -- Delta Parallel Robotic Arm by C# | How to Do Kinematic and Manual.

This article is edited by ZMOTION, here, share with you, let's learn together.

Note: Copyright belongs to Zmotion Technology, if there is reproduction, please indicate article source. Thank you.

How to Control SSI Absolute Encoder by EtherCAT Controller?

ZMOTION CONTROLLER — Tue, 24 Dec 2024 09:13:02 +0000

Before, “How to Use ZMC432-V2 EtherCAT Motion Controller to Read Position from BissC Absolute Encoder” had been shared, you can review that~

Then, today, let’s see another kind of encoder “SSI absolute encoder” in EtherCAT motion controller, still, taking the example of ZMC432-V2 EtherCAT motion controller.

What is SSI Absolute Encoder?

“SSI” means Synchronous Serial Interface, it is one digital interface protocol. Moreover, it is one communication protocol for data transferring between motion control and absolute encoder. And one main feature is "master-slave" interface because it uses synchronous serial interface mode.
Specifically, there are clock signal and pulse on the controller that can transfer data from the encoder to the controller synchronously. And the output data can be binary system or Gray-code.
Therefore, SSI absolute encoder is used to measure the position and angle. It only needs 2 cables to do the data transferring: Data & Clock. The principle is very simple, it converts the position information to binary code, encoding the codes as serial data, during the control, controller “clock” signal will control data’s transferring velocity.

SSI Absolute Encoder

SSI Interface

How EtherCAT Motion Controller Controls SSI Absolute Encoder?

(1) EtherCAT Motion Controller

A. Valid EtherCAT Motion Controller
For Zmotion, EtherCAT motion controller must meet below requirements:
*Controller Model: ZMC432-V2, ZMC406-V2

It supports rich motion control interfaces, and this kind of controller “ZMC” can run without PC.

It supports 32 axes motion control at most, that is, it can control 32 motors. All kinds of motion control functions and applications, it is OK.
*Firmware Version: above 4.930-20190305
*AXIS Interface: for ZMC432-V2 series, only AXIS4/5 support SSI/BISS communication.
You can check through "controller status", if there is "Ssi", which means it supports.

B. Development
--RTSys / ZDevelop: PLC / Basic / HMI.
--PC Languages: C#, C++, LabVIEW, Matlab, Qt, Linux, VB.Net, Python

(2) Wiring: EtherCAT Controller & SSI Absolute Encoder

EtherCAT motion controller has two pulse axes AXIS 4 & AXIS 5 that support SSI/BISS communication protocol, but SSI absolute encoder must be powered by 5V. And whatever SSI absolute encoder uses +5V power supply, the public end must be connected to controller GND.

ZMC432-V2 Controller AXIS 4 / 5 & SSI / BISS Interface

Wiring of EtherCAT Master & SSI Absolute Encoder

(3) Needed Parameters

--ATYPE: Axis Type--
48 = SSI absolute encoder, 49 = BISS absolute encoder
--UNITS: Pulse Amount--
Take SSI absolute encoder as the example, the resolution is 16-bit, then one circle corresponds to 65535 pulses, that is, the controller sets this axis' pulse amount UNITS according to this parameter.
--ENCODER_BITS: SSI/BISS Encoder Absolute Bit--
Refer to SSI absolute encoder manual data bit.

(4) Program Configuration

global CONST ENC_AxisStart = 4     'local absolute encoder axis starting axis No.
global CONST ENC_AxisNum = 2     'how many axes of local absolute encoder axes
'set local absolute encoder axis
for i = 0 to ENC_AxisNum - 1
   BASE(ENC_AxisStart + i)
   AXIS_ADDRESS=(-1<<16)+4+i     'map absolute encoder to axis 4, 5
   ENCODER_BITS = 26                     '26-bit absolute
   ATYPE=48                                        'SSI absolute encoder
Next

(5) Origin Settings

Generally, the origin position of absolute encoder is set through the signal.

If not to use signal, you also can contact with encoder manufacturer.

(6) Absolute Encoder Position Reading

After encoder position cleared when at the origin position, set UNITS, and read axis 4 / 5 MPOS values, then you will know encoder current position, if you need encoder original value, then read “ENCODER” of axis 4 / 5.
Note: SSI absolute encoder position supports power-down storage function.

Axis 4 SSI Absolute Encoder Position MPOS

Position Curve Captured by SCOPE when Rotating SSI Absolute Encoder Manually

Q & A of Related SSI Absolute Encoder:

--when downloading, it shows atype 48 error of axis 4 / axis 5--
Please check controller firmware version, it should be above 20190305, if not, contact with us to update it.

--no MPOS / wrong MPOS for axis 4 / axis 5--
Check wiring.
Check encoder_bit parameter configuration. You can online send the command “?* encoder_bits” to see if the parameter is set correctly.

That's all, thank you for your reading -- How to Control SSI Absolute Encoder in EtherCAT Motion Controller?

How to Control BissC Absolute Encoder in EtherCAT Motion Controller

ZMOTION CONTROLLER — Thu, 12 Dec 2024 08:10:45 +0000

What is Bissc Absolute Encoder?

BissC means Binary Synchronous Serial Communication . From the name, it can be known it is one digital interface protocol . Moreover, it is one communication protocol for data transferring between motion control and absolute encoder. And one main feature is "master-slave" interface because it uses fast dual-station synchronous serial interface mode.

In BissC protocol, master interface controls the sequence of position capture and data transferring speed, then encoder as the slave interface, mainly to respond main interface's position capture request.

BISS Interface

From above BISS Interface, it can be seen data transferring is made by two pairs of single-direction differential cables: Clock & Data .

--Clock: transfer "position capture request" and "time sequence information" from master interface to encoder--

--Data: back position data to interface that is synchronous with Clock--

Then for BissC absolute encoder, it is used to measure position and angle, and in industrial automation and control system, it plays an important role because more accurate and more specific position can be obtained by high-frequency signal.

BissC Absolute Encoder

BissC Absolute Grating Ruler

How EtherCAT Motion Controller Controls BissC Absolute Encoder?

(1) EtherCAT Motion Controller

A. Valid EtherCAT Motion Controller

For Zmotion, EtherCAT motion controller must meet below requirements:
*Controller Model: ZMC432-V2, ZMC406-V2
*Firmware Version: above 4.930-20190305
*AXIS Interface: for ZMC432-V2 series, only AXIS4/5 support SSI/BISS communication.
You can check through "controller status", if there is "Ssi", which means it supports.

B. Development

--RTSys: PLC / Basic / HMI.
--PC Languages: C#, C++, LabVIEW, Matlab, Qt, Linux, VB.Net, Python

For more details, please refer to ZMC432-V2 EtherCAT motion controller user manual.

(2) Wiring between EtherCAT & BissC Absolute Encoder

EtherCAT motion controller supports SSI/BISS communication protocol, it only supports the BissC absolute encoder of 5V power. And whatever BissC absolute encoder uses +5V power supply, the public end must be connected to controller GND.

ZMC432-V2 AXIS4/5 SSI/BISS

Wiring between ZMC432-V2 EtherCAT Motion Controller and BissC Absolute Encoder

(3) Needed Parameters

--ATYPE: Axis Type--

48 = SSI absolute encoder, 49 = BISS absolute encoder

--UNITS: Pulse Amount--

Take BissC absolute grating ruler as the example, resolution is 100nm, then one pulse corresponds to 100nm, 1mm = 10000 pulses, that is, controller sets this axis' UNITS according to this parameter.

--ENCODER_BITS: SSI/BISS Encoder Absolute Bit--

Refer to BissC absolute encoder manual data bit. Some BissC absolute encoders have more auxiliary state bits, generally there are 18-20 bits. ENCODER_BITS can manually adjust it. ENOCDER_BITS = data bit + auxiliary state bit (some encoders don't support).

(4) Program Configuration

global CONST ENC_AxisStart = 4     'local absolute encoder axis starting axis No.
global CONST ENC_AxisNum = 2     'how many axes of local absolute encoder axes
'set local absolute encoder axis
for i = 0 to ENC_AxisNum - 1
    BASE(ENC_AxisStart + i)
    AXIS_ADDRESS=(-1<<16)+4+i    'map absolute encoder to axis 4, 5
    ENCODER_BITS = 51      '32 bits absolute value, it is with 19 auxiliary state bits
    ATYPE=49               'BISS absolute encoder
Next

(5) Origin Settings

--Grating Ruler--

Use origin configuration tool to set the origin position.

--General Rotary Absolute Encoder--

Use signal to set origin position.

--Others--

Please contact with encoder manufacturers.

(6) Absolute Encoder Position Reading

A. How to Achieve

Step 1: clear encoder position at origin position.

Step 2: set UNITS

Step 3: read axis 4 / axis 5 MPOS value to get encoder current position, if you need encoder original value, read axis 4 / axis 5 ENCODER.

Note: BissC absolute encoder position supports power failure storage.

B. Example:

Manually rotate BissC absolute encoder, and capture the position curve by oscilloscope, then you will get:

C. Problems & Solutions

--when downloading, it shows atype 49 error of axis 4 / axis 5--

Please check controller firmware version, it should be above 20190305, if not, contact with us to update it.

--no MPOS / wrong MPOS for axis 4 / axis 5--

Check wiring.

Check encoder_bit parameters, manually adjust the state bit, send "encoder_bits" command in "output" window, see whether parameters are valid.

That's all, thank you for your reading -- How to Control BissC Absolute Encoder in EtherCAT Motion Controller

How to Control Delta Robotic Arm by EtherCAT Motion Controller?

ZMOTION CONTROLLER — Tue, 03 Dec 2024 07:02:10 +0000

_Read Me at First: _
A. This article is written by Zmotion, original article is https://www.zmotionglobal.com/support_info_136.html.
B. Article corresponding video description: https://youtu.be/GCFTSja_HOM.

Generally, Delta robotic arm supports 3-4 axes (joint axis 1 + joint axis 2 + joint axis 3 + [end rotary axis 4]). For Zmotion motion controllers, not all controllers support Delta robot function, only the controller that is with suffix “R” can be applied in Delta robot application, for example, ZMC406R.
Then, here we take ZMC406R EtherCAT Robot Motion Controller as the example to show you how to control your Delta robotic arm.

For development:
*ZDevelop / RTSys: it can develop, compile and debug your program in advance.
*PC Language: C++ / C# / Labview / Python, etc.

1. Brief Introduction of Robotic Arm

(1) Two Main Related Robotic Arm Definition

--Joint-Axis & Virtual-Axis--
A. Joint-Axis:
The joint axis refers to the rotary joint in the actual mechanical structure. In program, generally it shows the rotation angle (some structures are also translation axes). Since there is a reduction ratio between the motor and the rotary joint, when setting UNITS (the number of pulses when motor moves 1mm or 1°), it should be set according to the actual joint rotation. At the same time, when filling in the structural parameters in the TABLE, it should also be calculated according to the rotary joint center, not the center of the motor axis.

B. Virtual-axis
The virtual axis does not actually exist. It is 6 degrees of freedom of the world coordinate system, which are X, Y, Z, RX, RY, and RZ in turn. Also, it can be understood as the three linear axes and three rotary axes of the Cartesian coordinate system. This kind of axis can be used to determine the processing trajectory and coordinates of robot end working point.

--Forward Kinematics & Inverse Kinematics--
A. Forward Kinematics
By operating the joint coordinates, the spatial position of the end position in the Cartesian coordinate system can be calculated according to the mechanical structure parameters. This process is called “Forward Kinematics”. Now, the actual joint axis is operated, then the virtual axis automatically calculates the coordinates. And at this time, only joint-axis motion can be operated. Generally, forward kinematics is used to adjust joint position manually or point-homing when powered on.
B. Inverse Kinematics
Given a spatial position in a Cartesian coordinate system, calculate the coordinates of each joint axis. This process is called “Inverse Kinematics”. Now, the virtual axis is operated, then the actual joint axis automatically calculates the coordinates and moves.
There is one command for controller to build the inverse kinematics mode, “CONNFRAME”. This instruction acts on the joint axis. At this time, only the virtual axis can be operated (send motion command to virtual axis). Then, it can do linear motion, circular motion, space arc motions in the Cartesian coordinate system, for the joint axis, it will automatically move to the position where is after the inverse solution due to CONNFRAME command.

(2) How to Use Robotic Arm

A. Observe Motor Direction
At first, check whether the motor’s rotary direction is correct or not. When 3 joint axes rotate down, it is positive. Look down, when the end rotate axis rotates in the anticlockwise, it is positive. At this time, we can connect to robotic arm simulation tool “ZRobotView”, and click “Tool—Manual” in ZDevelop / RTSys, then operate 3 joint axes separately at one small speed. While moving, please see whether each joint-axis trends to end working point in the movement process of down. If “YES”, the direction is correct.

B. Save Robot Structure Parameters into TABLE Register
While building the robotic arm connection, it needs to fill in mechanical parameters into TABLE arrays according to below sequence.
--Mechanical Structural Parameters of Delta Robotic Arm FRAME 12--

‘starting from TableNum, save robotic arm structural parameters shown in above form into Table.
TABLE(TableNum,Top_R,Under_R,Top_L,Under_L,OneCirPules_J1,OneCirPules_J2,OneCirPules_J3,Offset_X,Offset_Y,Offset_Z,OneCirPules_J4)

C. Set Parameters of Joint-Axis & Virtual-Axis
All axes’ axis types and pulse amounts (units) should be set correctly. UNITS means the number of pulses for the motor in 1° motion. But for virtual-axis, its “units” is unrelated to actual sending pulses, it is used to set motion precision. And it is recommended to set virtual-axis’ units in 1mm is 1000, which means the accuracy is 3 digits after decimal part.

'joint-axis setting
BASE(Axis_JList(0),Axis_JList(1),Axis_JList(2),Axis_JList(3))
'set pulse axis type (ATYPE) as 1, if it is bus type, set it as 65. 
ATYPE = 1,1,1,1 
UNITS = UnitsJList(0),UnitsJList(1),UnitsJList(2),UnitsJList(3)
'set joint-axis speed, acceleration (usually be 10 times of speed), deceleration (usually be 10 times of speed)
SPEED = SpeedJList(0),SpeedJList(1),SpeedJList(2),SpeedJList(3) 
ACCEL = ADSpeedJList(0),ADSpeedJList(1),ADSpeedJList(2),ADSpeedJList(3)
DECEL = ADSpeedJList(0),ADSpeedJList(1),ADSpeedJList(2),ADSpeedJList(3)
'S curve setting
SRAMP = SrampJ(0),SrampJ(1),SrampJ(2),SrampJ(3)
'virtual-axis setting
BASE(Axis_VList(0),Axis_VList(1),Axis_VList(2))
'set virtual axes type as 0
ATYPE = 0,0,0
'set virtual axes’ pulse amount (ATYPE) as 1000, which means the precision is after 3 digits decimal part
UNITS = 1000,1000,1000
'set virtual-axis speed, acceleration (usually be 10 times of speed), deceleration (usually be 10 times of speed)
SPEED = SpeedVList(0),SpeedVList(1),SpeedVList(2)
ACCEL = AccelV(0),AccelV(1),AccelV(2)
DECEL = DecelV(0),DecelV(1),DecelV(2)
'S curve setting
SRAMP = SrampV(0),SrampV(1),SrampV(2)

D. Move Each Joint-Axis to Planned Origin Position
While robotic arm algorithm is building, it needs one origin position as the reference. When Delta robot each joint-axis’ connection rods L1 are all in horizontal position, it is considered as joint origin position. In real robotic arm machine on site, generally there is one location pin, if it doesn’t have the location pin, it can adjust L1 to be horizontal by “level instrument”.

E. Control Robotic Arm
There are two modes to control it, according to needs, build the forward kinematics or inverse kinematics.

(3) Robotic Arm Commands

Different robotic arm models are with different parameters. Please check details in “Zmotion Robotic Arm Command Manual”, then do selection.
Here, take Delta FRAME 12 model as the example. FRAME 12 means there is one end rotary axis, then use joint-axis to operate the rotary axis.

A. CONNREFRAME: Build Forward Kinematics Connection
--what is forward kinematics mode--
Associate virtual-axis coordinate with joint-axis coordinate, when joint-axis moves, virtual-axis will automatically move to corresponding position.
--how to use command--
CONNREFRAME(frame, tablenum, Axis_J1, Axis_J2, Axis_J3, Axis_J4)
Frame: the type of coordinate system. (for example, 12 means the robotic arm is 4-axis Delta robot, please refer to Zmotion robot command manual).
Tablenum: TABLE starting position that saves robotic arm structural parameters.
Axis_J1: the first joint-axis axis No.
Axis_J2: the second joint-axis axis No.
Axis_J3: the third joint-axis axis No.
Axis_J4: the fourth joint-axis axis No.

B. CONNFRAME: Build Inverse Kinematics Connection
--what is inverse kinematics mode--
Associate current joint-axis coordinate system demand position with virtual-axis coordinate system position. Please note the motion max speed of joint-axis coordinate system is limited by SPEED parameter. And when there is one alarm of joint-axis, the motion will be cancelled.
--how to use command--
CONNFRAME(frame, tablenum, Axis_Vx, Axis_Vy, Axis_Vz, Axis_J4)
Frame: the type of coordinate system. (for example, 12 means the robotic arm is 4-axis Delta robot, please refer to Zmotion robot command manual).
Tablenum: TABLE starting position that saves robotic arm structural parameters.
Axis_Vx: the first virtual-axis axis No.
Axis_Vy: the second virtual-axis axis No.
Axis_Vz: the third virtual-axis axis No.
Axis_J4: the fourth virtual-axis axis No.

2. How to Build Delta Robotic Arm Mode

(1) Forward Kinematics Connection

Take Delta robotic arm Frame 12 as the example. At first, save robotic arm structural parameters into Table in order, starting from one certain Table No., then select corresponding model axis list, at last, use CONNREFRAME command to build the forward kinematics mode.
For details of this command, please refer to “ZBasic Programming Manual”.

'save robotic arm parameters into Table array in order starting from TableNum
TABLE(TableNum,Top_R,Under_R,Top_L,Under_L,OneCirPules_J1,OneCirPules_J2,OneCirPules_J3,Offset_X,Offset_Y,Offset_Z,OneCirPules_J4)
'select axes
BASE(Axis_Vx,Axis_Vy,Axis_Vz,Axis_J4)
'build robotic arm forward kinematics
CONNREFRAME(FrameType,TableNum,Axis_J1,Axis_J2,Axis_J3,Axis_J4)

If the building succeeds, virtual axes’ MTYPE (current motion type) will become 34, now, only joint-axis can be operated in joint-axis coordinate to adjust the robotic arm attitude. In ZDevelop (RTSys), there is one “manual” tool, we can select joint-axis No. to do point or inch (here, we select axis 0, axis 1, and axis 2 joint axes, and axis 3 terminal rotate axis). At this time, virtual axis will automatically calculate the position of end working place in the Cartesian coordinate system.

(2) Inverse Kinematics Connection

Take Delta robotic arm Frame 12 as the example. At first, save robotic arm structural parameters into Table in order, starting from one certain Table No., then select corresponding model axis list, at last, use CONNFRAME command to build the inverse kinematics mode.
For details of this command, please refer to “ZBasic Programming Manual”.

'save robotic arm parameters into Table array in order starting from TableNum
TABLE(TableNum,Top_R,Under_R,Top_L,Under_L,OneCirPules_J1,OneCirPules_J2,OneCirPules_J3,Offset_X,Offset_Y,Offset_Z,OneCirPules_J4)
'select axes
BASE(Axis_J1,Axis_J2,Axis_J3,Axis_J4) 
'build robotic arm forward kinematics
CONNFRAME(FrameType,TableNum,Axis_Vx,Axis_Vy,Axis_Vz,Axis_J4)

If the building succeeds, joint axes’ MTYPE (current motion type) will become 33. “manual” also can be used here. Now, only virtual-axis can be operated by processing technology commands. That is, the trajectory edited before moves in the Cartesian coordinate system (here, take virtual axis 10, 11, 12 as the example), joint axis will automatically calculate how to do joint motion in the joint coordinate system.

3. How to Operate?

(1) Edit the Program

ZDevelop (RTSys) supports hybrid programming among Basic, HMI, and PLC. This routine matches Basic with HMI. For HMI, it can select “control” to drag and place for interacting the interface.

In this routine, define global SUB subfunction in BAS file at first, that is, edit sub-function’s function needs (project source codes can be referred at the end of this article), then use the control to bind, please note all controls’ actions select “calling function”.

A. Understand the Needs
--Condition--
Delta robotic arm builds the inverse kinematics, and take the origin position as the reference to determine one safe height.
--Basic Actions--
a. Delta moves up to above the fixed material in one certain safe height.
b. Delta moves down, opens OP port to get the material by “vacuum suction”.
c. Delay to move up to the safe height.
d. Move to fixed 2*2 disk position.
e. Down to disk position, close OP to place the material.
f. Repeat above, until the disk is full.
B. Process the Codes

'starting flag position 1
StartFlag = 1
LOCAL SafeHigh,i
'safe height
SafeHigh = DPOS(Axis_VList(2))-25
'row and colume
LOCAL Row,Col
'fixed material getting position
LOCAL SrcBorrow_X,SrcBorrow_Y,SrcBorrow_Z
SrcBorrow_X = 5
SrcBorrow_Y = 5
SrcBorrow_Z = SafeHigh-20
'select virtual axis
BASE(Axis_VList(0),Axis_VList(1),Axis_VList(2))
'set processing speed, acceleration, and deceleration
SPEED = SpeedVList(0)
ACCEL = AccelV(0)
DECEL = DecelV(0)
'open the continuous interpolation
MERGE = ON
'each on, temporary total numbers cleared 
TmpSum = 0
'move to the safe height (reference for origin position)
MOVEABS(0,0,SafeHigh)
FOR Col=1 TO 2
    FOR Row=1 TO 2
        'move to the position where is above the material placing position
        MOVEABS(SrcBorrow_X,SrcBorrow_Y,SafeHigh)
        'down to material getting place
        MOVEABS(SrcBorrow_X,SrcBorrow_Y,SrcBorrow_Z)
        'open OP to suck for getting the material
        MOVE_OP(8,ON)
        'delay
        MOVE_DELAY(300)
        'up to safe height
        MOVEABS(SrcBorrow_X,SrcBorrow_Y,SafeHigh)
        'move to the position where is above the disk that is for placing materials
        MOVEABS(-5*Row,5*Col,SafeHigh)
        'down to disk material placing position
        MOVEABS(-5*Row,5*Col,SrcBorrow_Z)
        'close OP to place the material
        MOVE_OP(8,OFF)
        'delay
        MOVE_DELAY(300)
        'up to safe height
        MOVEABS(-5*Row,5*Col,SafeHigh)
        'temporary total is added automatically
        TmpSum = TmpSum+1
    NEXT
NEXT
'wait until all axes stop
WAIT UNTIL IDLE(Axis_VList(0)) AND IDLE(Axis_VList(1)) AND IDLE(Axis_VList(2))
DELAY(10)
RAPIDSTOP(2)
DELAY(10)
'starting flag position 0
StartFlag = 0

(2) Debug & Analyze

A.Download the program into controller, then click “RTSys” – “Tool” – “Plugin” – “XPLC SCREEN”.

B. In appeared interaction interface, select “Forward” mode in main interface “mode” (robotic arm mode).

C. After forward building, open Zmotion Robotic Arm Solution “ZRobotView”, click “connect”, one “connect to controller” window appears, then select controller connection method (serial port or ethernet). Here, we select ethernet, it only needs to select controller IP, then click “connect”.

D. Now, it shows current robotic arm type in the above, and robotic arm structural parameters that are saved in Table all can be checked in this simulation tool, and corresponding robotic arm model will be built.

E. Open ZDevelop (RTSys) again, click *“SCOPE” *(oscilloscope). In the “scope” window, please select XYZ mode, that is, obverse the effect in 3D. For data source, select DPOS (demand position) here, and select axis No. of virtual axes. When all these parameters are set, click “stop” – “start” – “trigger”.

F. Switch to interaction interface, select “inverse” mode to build the inverse kinematics, then click “ON” to process needed technologies.

G. Return our programming software (ZDevelop / RTSys). In oscilloscope interface, processing effect is shown.

It can be seen Delta robotic arm always keeps moving up and down in one certain safe height in the process of getting and placing the material. In this way, real processing can be stable.

Develop EtherCAT Motion Control by LabView

ZMOTION CONTROLLER — Tue, 29 Oct 2024 10:08:32 +0000

If you master PC Labview knowledge, you can develop EtherCAT motion control and capture data in real-time easily.
Let's see how to do that.
Here, take one EtherCAT Motion Controller as the example.

1. How to Develop Motion Control by LabVIEW?

(1) Build LabVIEW Project

(2) Download "zauxdll" folder of LabVIEW Vi function library into PC, then copy it into "LabVIEW/user.lib".

Labview function library file and corresponding development examples can be obtained.

(3) PC Function | Related Interfaces

Zmotion provides general API function, it includes all kinds of host computer languages.

A. ZAux_OpenEth(): connection

B. ZAux_Direct_GetTable: get data from table, and import oscillocope data source

C. ZAux_Direct_GetDpos: get DPOS (demand position)

D. ZAux_Direct_GetMspeed: get feedback speed

E. ZAux_Direct_GetVpSpeed: get planning speed

F. ZAux_Direct_GetMpos: get MPOS (measurement position)

G. ZAux_Direct_Cam: do eletronic cam motion

(4) How to Get Real-Time Data

A. creat new vi in front board, and right click the mouse to select "control" to do UI designning, as it is shown in the below, the left is "connection" interface, the right is planning position of oscilloscope.

B. add "while" loop in added frame through mouse, then add "event structure" in "while", and right click to choose "add event branch", the "timeout" event, then get current needed data and import them into oscilloscope.

C. select event structure, and right-click to select "add event branch". In "while" structure, when the handle is blank, it will automatically get current controller IP, then use "Z Aux Open Eth.vi" function to connect to controller.

D. select event structure, and right-click to select "add event branch", the "disconnect" value changing, then use "Z Aux Close.vi" function to disconnect the connection.

E. select event structure, and right-click to select "add event branch", the "trigger" value changing, then use "Z Aux Trigger.vi" function to trigger oscillscope to capture the data.

F. select event structure, and right-click to select "add event branch", the "ON SCOPE " value changing, then use "Z Aux Execute.vi" function to call "SCOPE" command to open data acquisition, and save them into table register.

G. select event structure, and right-click to select "event", the "XY Graphic:" mouse changing . Then in this event branch, the coordinate position of the mouse within the corresponding range of the XY oscilloscope and the XY2 oscilloscope is read in real time and displayed on the interface.

H. select the condition structure. When the sine motion button is pressed, the two sine motions execute the two electronic cam motion commands in the sequence of tiling. Use the "Z Aux Cam.vi" function to move corresponding electronic cam motions according to data that has been loaded in table register in advance.

2. Debug & Watch

Compile the routine, and connect to ZDevelop / RTSys at the same time. Then run one "SIN" waveform trajectory through the corresponding single-axis routine. When the motion is running, capture the real-time data through LabVIEW oscillocope and ZDevelop oscilloscope synchronously.

(1) Algorithm Command: generate SIN waveform data

DIM  num_p,scale,m,t   'define variable
num_p=100
scale=500
FOR p=0 TO num_p
    TABLE(p,((-SIN(PI*2*p/num_p)/(PI*2))+p/num_p)*scale) 'save cam motion parameters into table
NEXT

(2) Waveform Comparison

A. ZDevelop and LabVIEW captures DPOS demand position.

--ZDevelop Oscilloscope Waveform--

--LabVIEW Oscilloscope Waveform--

It can be seen they are consistent.

B. ZDevelop and LabVIEW captures VP_SPEED.

Also, their waveforms are the same.

That's all, thank you for your reading -- EtherCAT Motion Controller LabVIEW Motion Control Development & Real-Time Data Reading.

This article is edited by ZMOTION, here, share with you, let's learn together.

Note: Copyright belongs to Zmotion Technology, if there is reproduction, please indicate article source. Thank you.

Have a good day, best wishes, see you next time.

How to Develop EtherCAT Motion Controller on ROS (2)

ZMOTION CONTROLLER — Tue, 22 Oct 2024 08:37:29 +0000

In last article, we have known ROS background, how to install ROS Melodic by Ubuntu18.04, and two ROS programming examples. Please visit “How to Develop EtherCAT Motion Controller on ROS (1)” for details.

Then, today, the second part is coming, that is, how to configure Zmotion dynamic library environment, and how one single-axis of EtherCAT motion controller on ROS is.

Still, the hardware takes ZMC432-V2 & ZMC408CE. They can be used in offline or online occasions.

For development, both use one same set of API function, C, C++, C#, LabVIEW, Python, Delphi all can be used, and mainstream platforms and operation systems all are valid, which means it is easy and convenient to develop.

1. Configure Zmotion Dynamic Link Library Environment

(1) Add Dynamic Link Library

New build folder "lib" under "content" -- zmotion(catkin_ws/src/zmotion/) of program package, and save dynamic link library "libzmotion.so".

A. add the third party path (under build) in CMakeLists.txt

link_directories(
lib
${catkin_LIB_DIRS}
)

B. also, link dynamic link library in CMakeLists,txt file(when calling the link libaray, remember to remove lib and .so)
target_link_libraries(talker ${catkin_LIBRARIES} zmotion)

(2) Add Library Function “zmcaux.cpp”, “zmotion.h”, “zmcaux.h”

A. add zmcaux.cpp file into "catkin_ws/src/zmotion/src"

B. add head file "zmotion.h and zmcaux.h" into "catkin_ws/src/zmotion/include/ zmotion"

C. and add these three library files in CMakeLists.txt:

add_executable(talker
src/talker.cpp
src/zmcaux.cpp
include/zmotion/zmotion.h
include/zmotion/zmcaux.h
)

D. modify head file's quote, like below image (need to fill corresponding address of "include" file, zmotion is the name of program package)

#include "zmotion/zmotion.h"
#include "zmotion/zmcaux.h"

2. Zmotion Controller Single-Axis Motion by ROS

“talker” node achieves axis 0 motion, and real time sends the position to “listener” node, then modifies "talker.cpp":

(1) Add Handle & Head File

#include "zmotion/zmotion.h"
#include "zmotion/zmcaux.h"
ZMC_HANDLE g_handle=NULL;

(2) Connect to Motion Controller Through EtherNET

ZMC_LinuxLibInit();
//EtherNET (Ethernet) to link
char ipaddr[16] = {"192.168.0.11"};
int x =ZAux_OpenEth(ipaddr,&g_handle); //***ZMC
ROS_INFO("connect to controller through Ethernet:%d",x);//Return 0 -- success

(3) Single-Axis Motion

ZAux_Direct_SetSpeed(g_handle, 0, 200); //set axis 0 motion speed as 200units/s
ZAux_Direct_SetAccel(g_handle, 0, 2000); //set axis 0 acceleration as 2000units/s/s
ZAux_Direct_SetDecel(g_handle, 0, 2000); //set axis 0 deceleration as 2000units/s/s
ZAux_Direct_SetSramp(g_handle, 0, 100); //set axis 0 S curve time as 100ms
ZAux_Direct_Single_Move(g_handle, 0, 300); //axis 0 moves 100 units that relates to current position

(4) Send Real-Time Position to “listener” Node

float piValue;
while (ros::ok())
{
    std_msgs::Float64 msg;
    ZAux_Direct_GetMpos(g_handle, 0, & piValue);//read time
    msg.data = piValue;
    //output, used to replace prinf/cout
    ROS_INFO("Position is: %f", msg.data);
    chatter_pub.publish(msg);
    ros::spinOnce();
    //sleep, make publishment frequency as 10Hz
    loop_rate.sleep();
}

(5) Compile

cd ~/catkin_ws/
catkin_make

(6) Run the Program

//open one new end station
roscore
//open another new end station
cd ~/catkin_ws/
rosrun zmotion talker
//open another new end station
cd ~/catkin_ws/
rosrun zmotion listener

Following is the running effect, real-time output position:

In addition, it can be seen that axis 0 is running S curve motion from the oscilloscope.

That's all, thank you for your reading -- How to Develop EtherCAT Motion Controller on ROS (2)

Have a good day, best wishes, see you next time.

How to Develop EtherCAT Motion Controller on ROS (1)

ZMOTION CONTROLLER — Fri, 18 Oct 2024 05:56:19 +0000

It can be referred from the title, this article will talk about “How to Develop EtherCAT Motion Controller on ROS”. And here takes ZMC432-V2 EtherCAT Motion Controller as the example.

1. What Is ROS ?

ROS (robot operating system) is one operating system (secondary operating system) after opening source for robots. The main aim is to promote code reuse ration in the field of robotic R&D.

ROS is a processing frame of distributed type (also can be called as Nodes), then execution files can be designed independently and they can loosen couple while running. In addition, these processes can be encapsulated into data packages (Packages) and stack (Stacks) for sharing and distributing.

What's more, ROS supports joint system of code library, then cooperation also can be distributed. In this way, this kind of design (from file system level to community level) makes it possible to independently determine development and implement work. All above functions are achieved through ROS basic tools.

Simply, ROS as a kind of flexible operating system, it is really random on system nodes, they can be located in different PC, even in different Ethernet. Then, we can use one Arduino as one node to post message, and use one laptop as one node to subscribe above information and use one phone as one node to drive motor. Therefore, it can be seen ROS can be applied in all kinds of occasions.

(1) ROS Main Features

A. Distributed & Point to Point
The point to point design of ROS and mechanisms such as service and node managers can disperse the real-time computing pressure brought by functions of PC vision and audio recognition, which can adapt to the challenges encountered by multi-robots.

B. Multiple Program Languages
ROS supports several kinds of programming languages, such as, C++, Python, Octave, and LISP. Also, it includes multiple kinds of interfaces of other languages.

C. Simplification & Integration
Systems built by ROS are modular, and codes in each module can be compiled independently. And "simplification" theory can be easily achieved through "CMake" tool (for compiling).
And complex codes are encapsulated into the library by ROS. It only builds some application programs to show library, which means it allows simple codes that exceed prototype to be transplanted and reused.

D. Rich Tool Package
To manage complicated ROS software framework, we use a lot of small tools to compile and run all kinds of ROS components. Then, the kernel is designed, namely, it is not to build a huge development and running environment.

E. Free & Open Source
All source codes of ROS are released in public.

(2) ROS Applications

In recent years, domestic and foreign robot enterprises, driverless enterprises, and drone enterprises (DJI drones) all have joined the ROS. Now actually many enterprises need engineers who knows or masters ROS knowledge. Then it can be known ROS is popular increasingly. Please see below ROS typical applications.
A. “Boss" in robot controllers -- KEBA , their controllers support ROS.

B. Robonaut 2 developed based on ROS by USA NASA has been already working on the International Space Station.

C. The bottom layer of Baidu's Apollo unmanned vehicle is developed based on ROS. It can be found on github (apollo-platform).

D. ROS-I prepares to cooperate with Microsoft and BMW to develop a set of automation solutions (Reference: A ROS-Industrial Collaboration with Microsoft and BMW).

E. Many industrial robotic arms use ROS system. Among them, the 5th anniversary video officially released by ROS-I at the end of 2017 is full of robots in the four major families. The KUKA youbot robot in the picture below is developed by using the ROS system.

2. How to Install the Software ?

This part mainly talks about the detailed process of installing ROS Melodic on Ubuntu 18.04 (this article takes Ubuntu 18.04 as an example, the same is true for others, and it does not affect the use of motion controller).

(1) Set “sources.list”

$ sudo sh -c '. /etc/lsb-release && echo "deb
http://mirrors.ustc.edu.cn/ros/ubuntu/ $DISTRIB_CODENAME main" >
/etc/apt/sources.list.d/ros-latest.list'

(2) Set “key” (key is updated)

$ sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-key
421C365BD9FF1F717815A3895523BAEEB01FA116

(3) Update “package” (maybe a long time, please wait a moment)

$ sudo apt-get update
At this time, it may meet following questions.

Solution is following, enter in end:
$sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-key F42ED6FBAB17C654 $ sudo apt-get update

When “Reading package lists … Done” appears, which means updating succeeds.

(4) Install “ROS melodic” (full version)

$ sudo apt-get install ros-melodic-desktop-full

(5) Initialize “rosdep”

$sudo rosdep init
$rosdep update
$echo "source /opt/ros/melodic/setup.bash" >> ~/.bashrc
$ source ~/.bashrc

Effects:

If you meet following problems when input the instruction "sudo rosdep init":
A. sudo: rosdep: command not found
Enter in the terminal: sudo apt install rospack-tools
B. ERROR: cannot download default sources list from: https://raw.githubusercontent.com/ros/rosdistro/master/rosdep/sources.list.d/20-default.list Website may be down.
--enter "sudo gedit /etc/hosts" in the terminal, then open hosts file--

--add "199.232.28.133 raw.githubusercontent.com" in the file, and new file added as follow--

--save file and exit--

--execute “sudo rosdep init” in the terminal, then problem is solved--

(6) test whether ROS is installed successfully or not

$ roscore
If it is successful, like this:

3. ROS Programming Examples

There are mainly two ROS routines, “message publish” and “subscription”.

(1) Build One ROS Work Space

$mkdir -p ~/catkin_ws/src
$cd ~/catkin_ws/
$ catkin_make

(2) Create One ROS Program Package (zmotion is the package name, it can be defined as others)

$cd ~/catkin_ws/src
$catkin_create_pkg zmotion std_msgs roscpp
$cd ~/catkin_ws
$ catkin_make

(3) After Creating the Program Package, “source ~ / catkin_ws / devel / setup.bash is required in each running, otherwise the file cannot be found.

Enter in the terminal:
$ gedit ~/.bashrc
add at the end of the file and save
$ source ~/catkin_ws/devel/setup.bash

(4) New Build One Node File

Create a src directory in the zmotion package directory:

$ cd ~/catkin_ws/src/zmotion   //enter the ZMotion package path
$ mkdir -p src   //new build the src folder for saving c++ program
$ cd src/   // enter the src folder path
$ touch talker.cpp   //create a new publishment message node cpp file
$ touch listener.cpp   //create a new subscription message node cpp file

(5) Edite “Publish Node” (talker.cpp)

Functions to be achieved:
--initialize ROS system
--publish message of std_msgs/Float64 on chatter topic
--publish the message in 10 times/s

#include "ros/ros.h"
#include "std_msgs/Float64.h"
#include <sstream>
int main(int argc, char **argv)
{
//Initialize ROS, name remapping (unique), it must be base name, excluding/
ros::init(argc, argv, "talker"); 
//build one handle for node of processing, the first built NodeHandle is the initialization node.
ros::NodeHandle n;
//tell host computer publish one std_msgs message in chatter topic
//main computer will subscribe all nodes of chatter topic, parameter means the size of published array (input firstly, then output)
ros::Publisher chatter_pub = n.advertise("chatter", 1000);
ros::Rate loop_rate(10);  //self-cycle frequency
int count = 0;
while (ros::ok())
{
std_msgs::Float64 msg;
             msg.data = count*1.0;
             //output, replace prinf/cout
             ROS_INFO("Position is: %f", msg.data); 
chatter_pub.publish(msg);
ros::spinOnce();
             //sleep, make publish frequency is 10Hz
             loop_rate.sleep();
             ++count;
           }
           return 0;
         }

(6) Edit “Subscript Node” (listener.cpp)

Functions to be achieved:
--initialize ROS system
--subscript message of chatter topic
--enter self-cycle, waiting for message
--message arrived, call chatterCallback() function.

#include "ros/ros.h"
#include "std_msgs/Float64.h"
//callback function
void chatterCallback(const std_msgs::Float64::ConstPtr& msg)
{
ROS_INFO("I heard: %f", msg->data);
}
int main(int argc, char **argv)
{
ros::init(argc, argv, "listener");
ros::NodeHandle n;
//tell master to subscribe chatter topic message.
ros::Subscriber sub = n.subscribe("chatter", 1000, chatterCallback);
ros::spin(); //self-cycle frequency
return 0;
}

(7) Modify “CMakeLists.txt”

A. Open the path of program package "zmotion(catkin_ws/src/zmotion)", find the file "CMakeLists.txt".

B. The lowest version is modified as 2.8.3
cmake_minimum_required(VERSION 2.8.3)

C. Find the file "find_package", and add the dependent package "message_generation".

find_package(catkin REQUIRED COMPONENTS
roscpp
std_msgs
message_generation
)

D. Make sure "generate_message" that is called.

generate_messages(
DEPENDENCIES
std_msgs
)

E. Make sure dependent of this message is added in dependent when running.

catkin_package(
# INCLUDE_DIRS include
# LIBRARIES beginner_tutorials
# CATKIN_DEPENDS roscpp std_msgs
# DEPENDS system_lib
CATKIN_DEPENDS message_runtime
)

F. Modify the configuration under "build".

--comment "include" in include_directories.

include_directories(
include
${catkin_INCLUDE_DIRS}
)

--add below codes in assigned position, following codes can be added in "build" randomly. It is better to add in relative positions for good appearance. It takes effect as long as it is added in the "build".

add_executable(talker src/talker.cpp)
add_executable(listener src/listener.cpp)
add_dependencies(talker $zmotion_generate_messages_cpp)//Zmotion is package name
target_link_libraries(talker
${catkin_LIBRARIES}
)
target_link_libraries(listener
${catkin_LIBRARIES}
)

a. at last, list full CMakeLists.txt.

cmake_minimum_required(VERSION 2.8.3)
project(zmotion)
find_package(catkin REQUIRED COMPONENTS
  roscpp
  std_msgs
  message_generation
)
## Generate added messages and services with any dependencies listed here
generate_messages(
   DEPENDENCIES
   std_msgs
)
###################################
## catkin specific configuration ##
###################################
catkin_package(
# INCLUDE_DIRS include
# LIBRARIES zmotion
# CATKIN_DEPENDS roscpp std_msgs
# DEPENDS system_lib
CATKIN_DEPENDS message_runtime
)
###########
## Build ##
###########
## Specify additional locations of header files
## Your package locations should be listed before other locations
include_directories(
  include
  ${catkin_INCLUDE_DIRS}
)
## Declare a C++ executable
## With catkin_make all packages are built within a single CMake context
## The recommended prefix ensures that target names across packages don't collide
add_executable(talker src/talker.cpp)
add_executable(listener src/listener.cpp)
## Rename C++ executable without prefix
add_dependencies(talker $zmotion_generate_messages_cpp)
## Specify libraries to link a library or executable target against
target_link_libraries(talker
   ${catkin_LIBRARIES}
)
target_link_libraries(listener
   ${catkin_LIBRARIES}
)

b. modify “package.xml” file.
<!-- build dependent. Select one between following two, or both are entered -->
<build_depend>message_generation</build_depend>
<build_export_depend>message_generation</build_export_depend>
<!-- Execute dependent, below must be added: -->
<exec_depend>message_runtime</exec_depend>

c. Compile

$ cd ~/catkin_ws
$ catkin_make

d. Run the Program
--open one new end station, turn on the ROS system--
$ roscore
--open one new end station, run “publish node”--

$ cd ~/catkin_ws   //enter work widget content
$ rosrun zmotion talker   //run “publish node” program

--open one new end station, run “subscript node”--

$ cd ~/catkin_ws
$ rosrun zmotion listener

--Result--
results of “Publish Node”

[INFO] [WallTime: 1314931831.774057] Position is: 1.000000
[INFO] [WallTime: 1314931832.775497] Position is: 2.000000
[INFO] [WallTime: 1314931833.778937] Position is: 3.000000
[INFO] [WallTime: 1314931834.782059] Position is: 4.000000
[INFO] [WallTime: 1314931835.784853] Position is: 5.000000

results of “Subscript Node”

[INFO] [WallTime: 1314931970.262246] I heard: 1.000000
[INFO] [WallTime: 1314931971.266348] I heard: 2.000000
[INFO] [WallTime: 1314931972.270429] I heard: 3.000000
[INFO] [WallTime: 1314931973.274382] I heard: 4.000000
[INFO] [WallTime: 1314931974.277694] I heard: 5.000000

ABOUT ZMOTION
That's all, thank you for your reading -- How to Develop EtherCAT Motion Controller on ROS (1)