Programming Dynamic CNC Paths

This example shows how a CNC path can be created directly in the application in runtime mode, and not stored from a CNC program object or a file with G code. When this kind of conventional CNC program is compiled, the path data is stored in a data structure of type SMC_CNC_Data. This internal data is then compiled in specific global data structures depends on the compile mode (SMC_CNC_REF or SMC_OutQueue).

In compile mode SMC_CNC_REF, the data is stored in an array of SMC_GEOINFO elements. The array in the application code is usually passed to the function block instance SMC_NCDecoder. At runtime, the data is decoded there and stored in a global data structure of type SMC_OUTQUEUE. Then path preprocessing function blocks can be called.

In compile mode SMC_OutQueue, a global data structure (SMC_OUTQUEUE) is generated directly. This data structure in the application code is passed to the interpolator (FB instance SMC_Interpolator). The function block SMC_NCDecoder is not called.

In compile mode FILE, the data is stored in a file. The data is stored as an array of elements of type SMC_GEOINFO and correspond to the data that is generated in compile mode SMC_CNC_REF.

Instead of programming the CNC path, you can program an application code that instantiates a data structure of type SMC_OUTQUEUE at runtime and assigns its values. You program a CNC path that is generated dynamically at runtime. You can pass the data structure to other function block instances (for example to the path preprocessing function blocks or to the function block SMC_Interpolator).

Programming

Programming

Note

The sample project CNCDynamicPath is located in the installation directory of CODESYS. The sample project was developed from the CNConline project. It includes the Path program instead of the graphically programmed Example path. A data structure of type SMC_OUTQUEUE is generated dynamically.

Declaration:

Declare a data structure of type SMC_OUTQUEUE. The data structure contains the CNC path data and is populated dynamically.

Example: QUEUE

Allocate memory for the path with the required amount to SMC_GEOINFO elements.

Example: BUF

Declare a variable of type SMC_GEOINFO with an initial step.

Example: GEO

Implementation:

An array element of data type SMC_GEOINFO corresponds to a path element in the CNC code. The following steps must be performed for each element in order to add the element to the SMC_OUTQUEUE:

Every array element has a start position that corresponds to the end position of the previous array element.

Example: GEO.piStartPos.dX := 0; or GEO.piStartPos := GEO.piDestPos;

Determine a movement type for each array element.

Example: GEO.iMoveType := CCLW; or GEO.iMoveType := LIN;

Set the parameters of the movement type. This is not required for all movement types.

Example: For an arc (movement type: CCLW), setting the following positions is required: geoinfo_A[i].dP1 := 200; geoinfo_A[i].dP2 := 100; geoinfo_A[i].dP3 := 50; geoinfo_A[i].dT1 := 0; geoinfo_A[i].dT2 := 90;

Insert the calculation of the end position.

SMC_CalcEndPnt(ADR(GEO));

Insert the calculation of the object length.

SMC_CalcLengthGeo(ADR(GEO));

Save the object in QUEUE:

SMC_AppendObj(POQ:=ADR(QUEUE), PGI:=ADR(GEO));

When the path is created completely, the end markers must be set: QUEUE-bEndOfList = TRUE;.

Note

Then, when a path preprocessing function block is called, it is required to set the start or end bit for InternMark.

Example

CNC path with two path elements

In this example, the arrays are not defined with the xy-positions. If this should be an example with two path elements as described, then these arrays would have to have two elements each. Derived from the sample project: xp:ARRAY[1..2] OF REAL:= [100,50]; yp:ARRAY[1..2] OF REAL:= [0,100];

PROGRAM Path
VAR
       iState : INT;
       QUEUE : SMC_OUTQUEUE;
       BUF : ARRAY[0..49] OF SMC_GEOINFO;
               // Memory allocation
        GEO : SMC_GEOINFO:=(dT1:=0, dT2:=1, dToolRadius:=0, dVel:=100, dVel_End:=100, dAccel:=200, dDecel:=500, iObj_Nr:=0);
               // Initial path element
       n : INT := 0;
       QUEUE.nSize := SIZEOF(BUF);
END_VAR

CASE iState OF
0:
       QUEUE.pbyBuffer := ADR(BUF[0]);
               // Initialize QUEUE
       SMC_SetQueueCapacity(ADR(QUEUE), SIZEOF(BUF));
       iState := iState + 1;

1:
       // Fill QUEUE
       WHILE NOT QUEUE.bFull DO
                // When QUEUE is full, wait until it has been processed by the following FBs
               n := n + 1;
               GEO.iSourceLine_No := n;
               GEO.piStartPos := GEO.piDestPos;
                       // Copying last destination
               GEO.iMoveType := LIN;
                       // Generating linear movement
               GEO.iObjNo := GEO.iObjNo + 1;
                       // Calculating number
               GEO.piDestPos.dX := xp[n];
                       // Generatint position
               GEO.piDestPos.dY := yp[n];
               SMC_CalcLengthGeo(pg := ADR(GEO));
                        // Calculating length of object with the help of the standard function
               SMC_AppendObj(poq:=ADR(QUEUE), pgi:=ADR(GEO));
                       // Appending object to QUEUE
               IF n = SIZEOF(xp)/SIZEOF(xp[1]) THEN
                       // All target positions processed
                       QUEUE.bEndOfList := TRUE;
                       n := 0;
                       iState := 2;
                       EXIT;
               END_IF
       END_WHILE

2:
       //Done
       ;
END_CASE

CheckVel(bExecute:=TRUE , poqDataIn:=ADR(queue)); // Preprocessing

Notice

If the SMC_OUTQUEUE data structure is populated with SMC_GEOINFO data and the data structure element was set to bFULL = TRUE, then we do not recommend a further assignment of SMC_GEOINFO data. In this case, the creation of the path is created at runtime until the first element of the SMC_OUTQUEUE data structure is processed in the interpolator. Only this is another element inserted.

Avoid this interruption by allocating enough memory. See variable BUF.