6.6.4 **minimal_welding_sample.cpp**
-------------------------------------------
This example (``4_minimal_welding_sample.cpp``) demonstrates how to configure and execute a
digital welding process over EtherNet/IP using the Doosan Robotics API:

- register monitoring / alarm / access control callbacks
- open a TCP/IP connection and request control authority
- turn Servo On and print system/library versions
- switch to AUTONOMOUS mode and the virtual robot system
- execute a full DRL-based welding sequence
- configure the welding interface and motion purely via the C++ API and run a weave weld

This example is located in the following path: |br|
``API-DRFL/example/Linux_64/4_minimal_welding_sample.cpp``

**See the example on the** `Doosan Robotics API-DRFL GitHub <https://github.com/DoosanRobotics/API-DRFL/blob/main/example/Linux_64/4_minimal_welding_sample.cpp>`_.

**Watch the full walk-through on the** `Doosan Robotics Official YouTube <https://www.youtube.com/watch?v=dL_1KRr5LDU>`_.

.. raw:: html

   <div style="text-align:center; margin: 1em 0;">
     <iframe width="640" height="360"
             src="https://www.youtube.com/embed/dL_1KRr5LDU"
             title="Tutorial Video"
             frameborder="0"
             allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
             allowfullscreen>
     </iframe>
   </div>


.. note::

  The ``app_weld_*`` functions that this sample calls are declared only when ``DRCF_VERSION`` is 2 (DRCF v2 controllers). The sample does not define ``DRCF_VERSION``, and ``DRFLEx.h`` defaults it to 3. See :ref:`DRCF Version Compatibility <env_drcf_version>`.


Setup & Global Variables
~~~~~~~~~~~~~~~~~~~~~~~~

The sample defines a global controller object, several state flags, the controller IP address and a helper function that returns a DRL welding script as a string.

.. code-block:: cpp

   #include <iostream>
   #include <cstring>
   #include <thread>
   #include <chrono>
   #include <termios.h>
   #include <unistd.h>

   #include "../../include/DRFLEx.h"
   using namespace DRAFramework;
   using namespace std::chrono_literals;

   #undef NDEBUG
   #include <assert.h>


   CDRFLEx Drfl;
   bool g_bHasControlAuthority = FALSE;
   bool g_TpInitailizingComplted = FALSE;
   bool moving = FALSE;
   bool bAlterFlag = FALSE;

   std::string IP_ADDR = "127.0.0.1";
   std::string getWeldingSampleDrl();

A set of callback handlers reacts to TP initialization, homing completion, program stop and monitoring data. The monitoring data handlers and ``OnProgramStopped`` have empty bodies.

.. code-block:: cpp

   void OnTpInitializingCompleted() {
     // Tp 초기화 이후 제어권 요청.
     g_TpInitailizingComplted = TRUE;
     Drfl.ManageAccessControl(MANAGE_ACCESS_CONTROL_FORCE_REQUEST);
   }

   void OnHommingCompleted() {
     // 50msec 이내 작업만 수행할 것.
     cout << "homming completed" << endl;
   }

   void OnProgramStopped(const PROGRAM_STOP_CAUSE v) {
   }

   void OnMonitoringDataCB(const LPMONITORING_DATA pData) {
   }

   void OnMonitoringDataExCB(const LPMONITORING_DATA_EX pData) {

   }

   void OnMonitoringCtrlIOCB(const LPMONITORING_CTRLIO pData) {
   }

   void OnMonitoringCtrlIOExCB(const LPMONITORING_CTRLIO_EX2 pData) {

   }

These globals and callbacks track control authority, request it again when the TP finishes initializing or the authority is lost, reconnect when the connection drops, and print alarm, popup, TP log, progress and user-input messages.

Main Loop
~~~~~~~~~~~~~

The main loop runs after initialization and waits for a single-character command.

.. code-block:: cpp

   while (true) {
     cout << "\ninput key : ";
     char ch;
     cin >> ch;
     switch (ch) {
       case '0':
       {
         // drl sample.
         Drfl.drl_start(ROBOT_SYSTEM_VIRTUAL, getWeldingSampleDrl());
       }
       break;
       // ...
       case '2':{


       }
       break;
       default:
         break;
     }
   }

   Drfl.CloseConnection();
   return 0;

- ``0`` : run the **DRL-based welding script** returned by ``getWeldingSampleDrl()``.
- ``1`` : configure the welding interface directly via **C++ structures** and execute a **weaving welding motion** using ``amovel`` with a welding app type.
- ``2`` : an empty case.

Callback Registration
~~~~~~~~~~~~~~~~~~~~~~~~~~~

Unlike the minimal instruction example (where callbacks are registered on a key press),  
this welding sample registers all callbacks **at startup** before opening the connection.

.. code-block:: cpp

   int main(int argc, char** argv) {

     Drfl.set_on_homming_completed(OnHommingCompleted);
     Drfl.set_on_monitoring_data(OnMonitoringDataCB);
     Drfl.set_on_monitoring_data_ex(OnMonitoringDataExCB);
     Drfl.set_on_monitoring_ctrl_io(OnMonitoringCtrlIOCB);
     Drfl.set_on_monitoring_ctrl_io_ex(OnMonitoringCtrlIOExCB);
     Drfl.set_on_monitoring_state(OnMonitoringStateCB);
     Drfl.set_on_monitoring_access_control(OnMonitroingAccessControlCB);
     Drfl.set_on_tp_initializing_completed(OnTpInitializingCompleted);
     Drfl.set_on_log_alarm(OnLogAlarm);
     Drfl.set_on_tp_popup(OnTpPopup);
     Drfl.set_on_tp_log(OnTpLog);
     Drfl.set_on_tp_progress(OnTpProgress);
     Drfl.set_on_tp_get_user_input(OnTpGetuserInput);
     Drfl.set_on_rt_monitoring_data(OnRTMonitoringData);
     Drfl.set_on_program_stopped(OnProgramStopped);
     Drfl.set_on_disconnected(OnDisConnected);

     assert(Drfl.open_connection(IP_ADDR));

- ``OnMonitoringStateCB`` has an empty body; its state handling is commented out.
- ``OnMonitroingAccessControlCB`` answers a **REQUEST** with ``MANAGE_ACCESS_CONTROL_RESPONSE_YES``, sets ``g_bHasControlAuthority`` on **GRANT**, and clears it on **DENY** or **LOSS**.
- ``OnTpInitializingCompleted`` sets ``g_TpInitailizingComplted`` and immediately issues a **force request** for control authority.
- ``OnLogAlarm``, ``OnTpPopup``, ``OnTpLog``, ``OnTpProgress`` and ``OnTpGetuserInput`` print diagnostic information to the console.
- ``OnDisConnected`` retries ``open_connection()`` every second until it succeeds.
- The sample undefines ``NDEBUG`` before including ``assert.h``, so the ``open_connection()`` call inside ``assert()`` runs in every build and the program aborts if it returns false.

The access control callback updates ``g_bHasControlAuthority`` whenever the controller changes the access state. On **DENY** or **LOSS**, once the TP has finished initializing, it requests control authority again with a force request.

.. code-block:: cpp

   void OnMonitroingAccessControlCB(
       const MONITORING_ACCESS_CONTROL eTrasnsitControl) {
     // 50msec 이내 작업만 수행할 것.
     std::cout << "OnMonitroingAccessControlCB !! " << int(eTrasnsitControl) << std::endl;
     switch (eTrasnsitControl) {
       case MONITORING_ACCESS_CONTROL_REQUEST:
         assert(Drfl.ManageAccessControl(MANAGE_ACCESS_CONTROL_RESPONSE_YES));
         // Drfl.ManageAccessControl(MANAGE_ACCESS_CONTROL_RESPONSE_YES);
         break;
       case MONITORING_ACCESS_CONTROL_GRANT:
         g_bHasControlAuthority = TRUE;
         break;
       case MONITORING_ACCESS_CONTROL_DENY:
       case MONITORING_ACCESS_CONTROL_LOSS:
         g_bHasControlAuthority = FALSE;
         if (g_TpInitailizingComplted) {
           Drfl.ManageAccessControl(MANAGE_ACCESS_CONTROL_FORCE_REQUEST);
         }
         break;
       default:
         break;
     }
   }

When the access-control state changes, the callback prints the numeric value of ``MONITORING_ACCESS_CONTROL``, for example 2 for **GRANT**.

.. code-block:: text

   OnMonitroingAccessControlCB !! 2

Different integer values correspond to the enum constants defined in
``MONITORING_ACCESS_CONTROL`` (REQUEST, GRANT, DENY, LOSS, ...).  

The robot-state callback is registered, but every statement in its body is commented out.

.. code-block:: cpp

   void OnMonitoringStateCB(const ROBOT_STATE eState) {
       // std::cout << "monitoring state cb " << std::endl;
       // // 50msec 이내 작업만 수행할 것.
     // switch ((unsigned char)eState) {
     // ...
     //   default:
     //     break;
     // }
     // return;
   }

Alarm information from the controller is reported through the log-alarm callback.

.. code-block:: cpp

   void OnLogAlarm(LPLOG_ALARM tLog) {
     cout << "Alarm Info: "
          << "group(" << (unsigned int)tLog->_iGroup << "), index("
          << tLog->_iIndex << "), param(" << tLog->_szParam[0] << "), param("
          << tLog->_szParam[1] << "), param(" << tLog->_szParam[2] << ")" << endl;
   }

Example output:

.. code-block:: text

  Alarm Info: group(1), index(1037), param(), param(), param()

Each alarm is logged with a **group** and **index** code plus up to three
string parameters. These values can be cross-referenced with the alarm table
in the controller manual to identify the exact cause (e.g., Servo On failure,
limit violation, welding interface error, etc.).  

Connection to Controller
~~~~~~~~~~~~~~~~~~~~~~~~~~~

After registering callbacks, the controller connection is opened via TCP/IP, the monitoring version is set to the latest and the system version is read.

.. code-block:: cpp

   assert(Drfl.open_connection(IP_ADDR));

   Drfl.setup_monitoring_version(1); // (0 -> older version, 1 -> latest)

   SYSTEM_VERSION tSysVerion = {'\0',};
   Drfl.get_system_version(&tSysVerion);


Control Authority & Servo On Handling
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

The sample sends one force request for control authority and one Servo On command, prints the system and library versions, and then polls ``get_robot_state()`` every second.

.. code-block:: cpp

   if(true!=Drfl.ManageAccessControl(MANAGE_ACCESS_CONTROL_FORCE_REQUEST)) {
     std::cout << "ManageAccessControl failure " << std::endl;
   }
   // std::cout << "ManageAccessControl done " << std::endl;
   Drfl.set_robot_control(CONTROL_SERVO_ON);
   cout << "System version: " << tSysVerion._szController << endl;
   cout << "Library version: " << Drfl.get_library_version() << endl;
   // Drfl.set_digital_output(GPIO_CTRLBOX_DIGITAL_INDEX_10, TRUE);
   while ((Drfl.get_robot_state() != STATE_STANDBY) || !g_bHasControlAuthority)
   {
     std::cout << "Drfl.get_robot_state() :  " <<Drfl.get_robot_state()<< std::endl;
     this_thread::sleep_for(std::chrono::milliseconds(1000));
   }


.. code-block:: text

   System version: GF03050000
   Library version: GL013300

The loop has no retry limit. The program continues only when the robot state is **STATE_STANDBY** and the access-control callback has set ``g_bHasControlAuthority``.


Robot Mode & System Configuration
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

After Servo On, the robot mode is set to **AUTONOMOUS** and the robot system to the virtual robot.

.. code-block:: cpp

   std::cout << "set robot mode ret : " << Drfl.set_robot_mode(ROBOT_MODE_AUTONOMOUS) << std::endl;

   Drfl.set_robot_system(ROBOT_SYSTEM_VIRTUAL);

.. code-block:: text

   set robot mode ret : 1

DRL-based Welding Script
~~~~~~~~~~~~~~~~~~~~~~~~~~~

Key ``0`` executes a self-contained DRL script returned by ``getWeldingSampleDrl()`` on the virtual robot system.

.. code-block:: cpp

   case '0':
   {
     // drl sample.
     Drfl.drl_start(ROBOT_SYSTEM_VIRTUAL, getWeldingSampleDrl());
   }
   break;

The DRL string configures welding parameters and motions:

.. code-block:: cpp

   std::string getWeldingSampleDrl() {
     return R"(
   set_singular_handling(DR_AVOID)
   set_velj(60.0)
   set_accj(100.0)
   set_velx(250.0, 80.625, DR_OFF)
   set_accx(1000.0, 322.5)

   dry_run = 1 # (flag_dry_run: 실용접(0) / 모의용접(1))
   weld_con_adj = 1 # 용접 조건 조정 여부 설정 (app_weld_set_weld_cond_digital에서 설정한 조건 적용(1) / 조정값 적용(0))
   arc_sensing_test = False # Arc Sensing 시험을 위한 설정 (True: Arc Sensing 관련 DRL 실행 / False: Arc Sensing 관련 DRL 패스)


   app_weld_set_interface_eip_r2m_process(welding_start=[1,0,0,0,4,0,1,0,0], robot_ready=[1,0,0,0,5,0,1,0,0], error_reset=[1,0,0,1,4,0,1,0,0])
   app_weld_set_interface_eip_r2m_mode(welding_mode=[1,1,0,0,0,2,2,0,1], s_2t=[0,0,0,0,0,0,0,0,0], pulse_mode=[0,0,0,0,0,0,0,0,0],wm_opt1=[0,0,0,0,0,0,0,0,0])
   app_weld_set_interface_eip_r2m_test(gas_test=[1,0,0,0,6,0,1,0,0], inching_plus=[1,0,0,1,0,0,1,0,0], inching_minus=[1,0,0,1,2,0,1,0,0], blow_out_torch=[0,0,0,0,0,0,0,0,0], simulation=[1,0,0,1,7,0,1,0,0], ts_opt1=[0,0,0,0,0,0,0,0,0], ts_opt2=[0,0,0,0,0,0,0,0,0])
   app_weld_set_interface_eip_r2m_condition(job_num=[1,1,0,3,0,4,8,1,255], synergic_id=[1,1,0,2,0,3,4,0,15], r_wire_feed_speed=[0,0,0,0,0,0,0,0,0], voltage_correct=[0,0,0,0,0,0,0,0,0], dynamic_correct=[0,0,0,0,0,0,0,0,0])
   app_weld_set_interface_eip_r2m_option(opt1=[0,0,0,0,0,0,0,0,0], opt2=[0,0,0,0,0,0,0,0,0], opt3=[0,0,0,0,0,0,0,0,0], opt4=[0,0,0,0,0,0,0,0,0], opt5=[0,0,0,0,0,0,0,0,0], opt6=[0,0,0,0,0,0,0,0,0], opt7=[0,0,0,0,0,0,0,0,0], opt8=[0,0,0,0,0,0,0,0,0], opt9=[0,0,0,0,0,0,0,0,0], opt10=[0,0,0,0,0,0,0,0,0], opt11=[0,0,0,0,0,0,0,0,0], opt12=[0,0,0,0,0,0,0,0,0], opt13=[0,0,0,0,0,0,0,0,0], opt14=[0,0,0,0,0,0,0,0,0], opt15=[0,0,0,0,0,0,0,0,0])
   app_weld_set_interface_eip_m2r_process(current_flow=[1,0,0,0,0,0,1,0,0], process_active=[1,0,0,0,6,0,1,0,0], main_current=[1,0,0,0,5,0,1,0,0], machine_ready=[1,0,0,0,1,0,1,0,0], comm_ready=[0,0,0,0,0,0,0,0,0])
   app_weld_set_interface_eip_m2r_monitoring(welding_voltage=[1,2,1,6,0,6,16,0.0,100.0], welding_current=[1,2,1,8,0,6,16,0.0,1000.0], wire_feed_speed=[1,2,1,10,0,6,16,0.0,40.0], wire_stick=[0,0,0,0,0,0,0,0,0], error=[1,0,0,2,0,4,1,0,0], error_num=[1,0,0,1,0,4,8,0,0])
   app_weld_set_interface_eip_m2r_other(opt1=[0,0,0,0,0,0,0,0,0], opt2=[0,0,0,0,0,0,0,0,0], opt3=[0,0,0,0,0,0,0,0,0], opt4=[0,0,0,0,0,0,0,0,0], opt5=[0,0,0,0,0,0,0,0,0], opt6=[0,0,0,0,0,0,0,0,0], opt7=[0,0,0,0,0,0,0,0,0], opt8=[0,0,0,0,0,0,0,0,0], opt9=[0,0,0,0,0,0,0,0,0], opt10=[0,0,0,0,0,0,0,0,0])
   wait(0.5)

   app_weld_enable_digital()
   wait(1)


   app_weld_set_weld_cond_digital(flag_dry_run=dry_run, vel_target=3.0000, vel_min=0.0000, vel_max=100.0000, welding_mode=1, s_2t=0, pulse_mode=0, wm_opt1=0, simulation=0, ts_opt1=0, ts_opt2=0, job_num=4, synergic_id=1, r_wire_feed_speed=0, voltage_correct=0, dynamic_correct=0, r_opt1=0, r_opt2=0, r_opt3=0, r_opt4=0, r_opt5=0, r_opt6=0, r_opt7=0, r_opt8=0, r_opt9=0, r_opt10=0, r_opt11=0, r_opt12=0, r_opt13=0, r_opt14=0, r_opt15=0)

   app_weld_weave_cond_trapezoidal(wv_offset=[0.000,0.000], wv_ang=0.00, wv_param=[0.000,3.0,0.000,-3.0,0.30,0.10,0.20,0.30,0.10,0.20])

   ready_weld_pos = posx(-77.41, -640.26, 119.09, 54.84, 166.79, -48.59 )
   movel(ready_weld_pos, radius=0.00, ref=0, mod=DR_MV_MOD_ABS, ra=DR_MV_RA_DUPLICATE, app_type=DR_MV_APP_NONE)
   wait(1)
   #if weld_con_adj == 1:
   #   app_weld_adj_welding_cond_digital(flag_reset=weld_con_adj)

   #elif weld_con_adj == 0:
   #   app_weld_adj_welding_cond_digital(flag_reset=weld_con_adj, wv_width_ratio=0.5)

   end_weld_pos = posx(306.16,-617.1,173.77,54.18,166.75,-49.15)
   amovel(end_weld_pos, v=3.0000, a=70.0000, ref=0, mod=DR_MV_MOD_ABS, ra=DR_MV_RA_DUPLICATE, app_type=DR_MV_APP_WELD)
   tp_log("Start welding motion")
   mwait(1)
   app_weld_disable_digital()

   wait(1))";
   };

- Configure **EtherNet/IP mapping** (R2M / M2R) for welding control and monitoring.
- Enable the **digital welding interface** (``app_weld_enable_digital()``).
- Set welding conditions (speed, mode, job number, synergic ID, etc.).
- Configure **trapezoidal weaving** for the torch path.
- Move to a ready pose via ``movel``, then weld from **start** to **end** pose  
  using ``amovel(..., app_type=DR_MV_APP_WELD)``.
- Disable welding at the end of the motion.

By default, ``dry_run = 1`` performs a **simulation weld** (no real arc).  
To perform real welding, users must set ``dry_run = 0`` and ensure  
that the welding machine and EtherNet/IP mapping are configured correctly.

C++-based Welding Interface Configuration
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Key ``1`` demonstrates how to set up the same welding interface **purely via C++**  
and execute a welding motion without using DRL welding commands directly.

.. code-block:: cpp

   case '1':
   {
     // Set ready pos and get Target Welding position
     float ready_weld_posj[6] = {85.8353, -53.5421, -61.888, 6.7839, -76.0373, -19.6588};
     Drfl.movej(ready_weld_posj, 50, 50);
     LPROBOT_TASK_POSE posx = Drfl.get_current_posx();
     float target_wel_posx[6];
     for(int i=0; i<NUM_JOINT; i++) {
       target_wel_posx[i] = posx->_fTargetPos[i];
     }
     target_wel_posx[0] += 200;

     // Refer to drl Sample Code.
     Drfl.set_singularity_handling(SINGULARITY_AVOIDANCE_AVOID);
     unsigned char dry_run = 1; // (flag_dry_run: 실용접(0) / 모의용접(1))
     unsigned char weld_con_adj = 1; // 용접 조건 조정 여부 설정(app_weld_set_weld_cond_analog에서 설정한 조건 적용(1) / 조정값 적용(0))

     float velx[2] = { 250.0, 80.625 };
     float accx[2] = { 1000., 322.5 };
     float g_op_speed = 100;
     Drfl.set_robot_mode(ROBOT_MODE_AUTONOMOUS);
     // 사전 TCP 설정 : EWM 용접기 기준 Welding_Torch(0, 200, 300, 90, 67.5, 0)
     if (Drfl.get_tcp() != "Welding Torch")
       Drfl.set_tcp("Welding Torch");
     this_thread::sleep_for(200ms);
     // Drfl.change_operation_speed(g_op_speed);
     CONFIG_DIGITAL_WELDING_INTERFACE_PROCESS r2m_process_data = {
     // _bEnable / _nDataType / _nPositionalNumber / _fMinData / _fMaxData / _nByteOffset / _nBitOffset / _nComnDataType / _nMaxDigitSize
       {1, 0, 0, 0, 0, 0, 4, 0, 1}, // _tWeldingStart
       { 1, 0, 0, 0, 0, 0, 5, 0, 1}, // _tRobotReady
       {1, 0, 0, 0, 0, 1, 4, 0, 1} // _tErrorReset
     };
     Drfl.app_weld_set_interface_eip_r2m_process(r2m_process_data);
     // ...
     Drfl.app_weld_set_interface_eip_r2m_mode(r2m_mode_data);
     // ...
     Drfl.app_weld_set_interface_eip_r2m_test(r2m_test_data);
     // ...
     Drfl.app_weld_set_interface_eip_r2m_condition(r2m_condition_data);
     // ...
     Drfl.app_weld_set_interface_eip_r2m_option(r2m_option_data);
     // ...
     Drfl.app_weld_set_interface_eip_m2r_process2(m2r_process2_data);
     // ...
     Drfl.app_weld_set_interface_eip_m2r_monitoring(m2r_monitoring_data);
     // ...
     Drfl.app_weld_set_interface_eip_m2r_other(m2r_other_data);
     this_thread::sleep_for(500ms);
     Drfl.app_weld_enable_digital(1);
     this_thread::sleep_for(500ms);

     CONFIG_DIGITAL_WELDING_CONDITION weld_condition = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
     weld_condition._cVirtualWelding = dry_run;
     weld_condition._fTargetVel = 3.f;
     weld_condition._fMaxVelLimit = 100.f;
     weld_condition._nWeldingMode = 1;
     weld_condition._nPulseMode = 0;
     weld_condition._nJobNumber = 4;
     weld_condition._nSynergicID = 1;
     Drfl.app_weld_set_weld_cond_digital(weld_condition);
     // ...
     this_thread::sleep_for(1000ms);
     // ...
     CONFIG_TRAPEZOID_WEAVING_SETTING weaving_trap = { //Weaving_trap 설정
       0.f,
       0.f,
       0.f,
       { 0.f, 3.f },
       { 0.f, -3.f },
       0.3f,
       0.1f,
       0.2f,
       0.3f,
       0.1f,
       0.2f
     };
     // ...
     Drfl.app_weld_weave_cond_trapezoidal(weaving_trap);
     // ...
     float welding_velx[2] = { 3,3 };
     float welding_accx[2] = { 70,70 };
     Drfl.amovel(target_wel_posx, welding_velx, welding_accx, 0, MOVE_MODE_ABSOLUTE, MOVE_REFERENCE_BASE, BLENDING_SPEED_TYPE_DUPLICATE, DR_MV_APP_WELD);
     Drfl.mwait();
     break;
   }

- **Task pose offset**: the welding target is the task pose read after the move to the ready joint position, plus 200 on X.
- **Digital welding interface mapping** is done with a series of ``CONFIG_DIGITAL_WELDING_INTERFACE_*`` structures; the elided lines define each structure in the same way as ``r2m_process_data``.
- **Weaving parameters** (offsets, amplitude, timing) are configured through  
  ``CONFIG_TRAPEZOID_WEAVING_SETTING`` and applied via  
  ``app_weld_weave_cond_trapezoidal``.
- The final motion uses ``amovel(..., DR_MV_APP_WELD)``, which executes  
  a **linear weld with weaving** along the specified target pose.