MixedImpedanceVelocityController.cpp

Go to the documentation of this file.

/*
 * This file is part of ArmarX.
 *
 * ArmarX is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * ArmarX is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 *
 * @package    ...
 * @author     Jianfeng Gao ( jianfeng dot gao at kit dot edu )
 * @date       2024
 * @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
 *             GNU General Public License
 */
 
#include "MixedImpedanceVelocityController.h"
 
#include <VirtualRobot/MathTools.h>
 
#include <ArmarXCore/core/ArmarXObjectScheduler.h>
#include <ArmarXCore/core/time/CycleUtil.h>
#include <ArmarXCore/core/time/TimeUtil.h>
 
#include <armarx/control/common/utils.h>
#include <armarx/control/ethercat/RTUtility.h>
 
namespace armarx::control::njoint_controller::task_space
{
    NJointControllerRegistration<NJointTaskspaceMixedImpedanceVelocityController>
        registrationControllerNJointTaskspaceMixedImpedanceVelocityController(
            "NJointTaskspaceMixedImpedanceVelocityController");
 
    void
    NJointTaskspaceMixedImpedanceVelocityController::limbInit(const std::string nodeSetName,
                                                              ArmPtr& arm,
                                                              Config& cfg,
                                                              VirtualRobot::RobotPtr& nonRtRobotPtr)
    {
        arm->kinematicChainName = nodeSetName;
        VirtualRobot::RobotNodeSetPtr rtRns =
            rtGetRobot()->getRobotNodeSet(arm->kinematicChainName);
        VirtualRobot::RobotNodeSetPtr nonRtRns =
            nonRtRobotPtr->getRobotNodeSet(arm->kinematicChainName);
        ARMARX_CHECK_EXPRESSION(rtRns) << arm->kinematicChainName;
        ARMARX_CHECK_EXPRESSION(nonRtRns) << arm->kinematicChainName;
        ARMARX_IMPORTANT << "Creating Taskspace Impedance controller with kinematic chain: "
                         << arm->kinematicChainName << " with num of joints: (RT robot) "
                         << rtRns->getSize() << ", and (non-RT robot) " << nonRtRns->getSize();
 
        std::vector<size_t> jointIDTorqueMode;
        std::vector<size_t> jointIDVelocityMode;
        arm->jointNames.clear();
        for (size_t i = 0; i < rtRns->getSize(); ++i)
        {
            std::string jointName = rtRns->getNode(i)->getName();
            arm->jointNames.push_back(jointName);
 
            bool foundControlDevice = false;
            auto it = std::find(
                cfg.jointNameListTorque.begin(), cfg.jointNameListTorque.end(), jointName);
            if (it != cfg.jointNameListTorque.end())
            {
                ControlTargetBase* ct = useControlTarget(jointName, ControlModes::Torque1DoF);
                ARMARX_CHECK_EXPRESSION(ct);
                auto* casted_ct = ct->asA<ControlTarget1DoFActuatorTorque>();
                ARMARX_CHECK_EXPRESSION(casted_ct);
                arm->targetsTorque.push_back(casted_ct);
                jointIDTorqueMode.push_back(i);
                foundControlDevice = true;
            }
 
            it = std::find(
                cfg.jointNameListVelocity.begin(), cfg.jointNameListVelocity.end(), jointName);
            if (it != cfg.jointNameListVelocity.end())
            {
                ControlTargetBase* ct = useControlTarget(jointName, ControlModes::Velocity1DoF);
                ARMARX_CHECK_EXPRESSION(ct);
                auto* casted_ct = ct->asA<ControlTarget1DoFActuatorVelocity>();
                ARMARX_CHECK_EXPRESSION(casted_ct);
                arm->targetsVel.push_back(casted_ct);
                jointIDVelocityMode.push_back(i);
                foundControlDevice = true;
            }
            if (not foundControlDevice)
            {
                auto namesTorque = armarx::control::common::sVecToString(cfg.jointNameListTorque);
                auto namesVelocity =
                    armarx::control::common::sVecToString(cfg.jointNameListVelocity);
                ARMARX_ERROR << "Does not found valid control device for joint name: " << jointName
                             << "Please check torque controlled joints: [" << namesTorque
                             << "] and velocity controlled joints: [" << namesVelocity << "].";
            }
 
            const SensorValueBase* sv = useSensorValue(jointName);
            ARMARX_CHECK_EXPRESSION(sv);
            const auto* torqueSensor = sv->asA<SensorValue1DoFActuatorTorque>();
            const auto* velocitySensor = sv->asA<SensorValue1DoFActuatorVelocity>();
            const auto* positionSensor = sv->asA<SensorValue1DoFActuatorPosition>();
 
            if (torqueSensor == nullptr)
            {
                ARMARX_WARNING << "No Torque sensor available for " << jointName;
            }
            if (velocitySensor == nullptr)
            {
                ARMARX_WARNING << "No velocity sensor available for " << jointName;
            }
            if (positionSensor == nullptr)
            {
                ARMARX_WARNING << "No position sensor available for " << jointName;
            }
 
            arm->sensorDevices.torqueSensors.push_back(torqueSensor);
            arm->sensorDevices.velocitySensors.push_back(velocitySensor);
            arm->sensorDevices.positionSensors.push_back(positionSensor);
        };
        ARMARX_DEBUG << "Number of torque controlled joints " << jointIDTorqueMode.size();
        ARMARX_DEBUG << "Number of velocity controlled joints " << jointIDVelocityMode.size();
        ARMARX_CHECK_EQUAL(rtRns->getNodeNames().size(),
                           jointIDTorqueMode.size() + jointIDVelocityMode.size());
 
        arm->controller.initialize(nonRtRns, rtRns, jointIDTorqueMode, jointIDVelocityMode);
        arm->controller.ftsensor.initialize(rtRns, robotUnit, cfg.ftConfig);
 
        validateConfigData(cfg, arm);
        arm->rtConfig = cfg;
        arm->nonRtConfig = cfg;
    }
 
    NJointTaskspaceMixedImpedanceVelocityController::
        NJointTaskspaceMixedImpedanceVelocityController(const RobotUnitPtr& robotUnit,
                                                        const NJointControllerConfigPtr& config,
                                                        const VirtualRobot::RobotPtr&) :
        robotUnit(robotUnit)
    {
        ARMARX_CHECK_EXPRESSION(robotUnit);
 
        ConfigPtrT cfg = ConfigPtrT::dynamicCast(config);
        ARMARX_CHECK_EXPRESSION(cfg);
        userConfig.fromAron(cfg->config);
 
        useSynchronizedRtRobot();
        nonRtRobot = robotUnit->cloneRobot();
        robotUnit->updateVirtualRobot(nonRtRobot);
 
        for (auto& pair : userConfig.cfg)
        {
            limb.emplace(pair.first, std::make_unique<ArmData>());
            limbInit(pair.first, limb.at(pair.first), pair.second, nonRtRobot);
        }
    }
 
    std::string
    NJointTaskspaceMixedImpedanceVelocityController::getClassName(const Ice::Current&) const
    {
        return "NJointTaskspaceMixedImpedanceVelocityController";
    }
 
    void
    NJointTaskspaceMixedImpedanceVelocityController::onInitNJointController()
    {
        std::string taskName = getClassName() + "AdditionalTask";
        runTask(taskName,
                [&]
                {
                    armarx::control::ethercat::RTUtility::pinThreadToCPU(
                        4); // please don't set this to 0 as it is the rtRun/control thread
                    armarx::control::ethercat::RTUtility::elevateThreadPriority(
                        armarx::control::ethercat::RTUtility::RT_THREAD_PRIORITY);
 
                    CycleUtil c(1);
                    getObjectScheduler()->waitForObjectStateMinimum(eManagedIceObjectStarted);
                    ARMARX_IMPORTANT << "Create a new thread for " << getClassName();
                    while (getState() == eManagedIceObjectStarted)
                    {
                        if (isControllerActive())
                        {
                            additionalTask();
                        }
                        c.waitForCycleDuration();
                    }
                });
    }
 
    void
    NJointTaskspaceMixedImpedanceVelocityController::limbNonRT(ArmPtr& arm)
    {
        arm->nonRtConfig = arm->bufferConfigUserToNonRt.getUpToDateReadBuffer();
        arm->bufferConfigNonRtToRt.getWriteBuffer() = arm->nonRtConfig;
        arm->bufferConfigNonRtToRt.commitWrite();
    }
 
    void
    NJointTaskspaceMixedImpedanceVelocityController::additionalTask()
    {
        robotUnit->updateVirtualRobot(nonRtRobot);
        bool rtSafe = true;
        for (auto& pair : limb)
        {
            limbNonRT(pair.second);
            pair.second->rtStatusInNonRT =
                pair.second->bufferRtStatusToNonRt.getUpToDateReadBuffer();
            rtSafe = rtSafe and pair.second->rtStatusInNonRT.rtSafe;
        }
        if (not rtSafe)
        {
            for (auto& pair : limb)
            {
                ARMARX_RT_LOGF_WARN(
                    "new target \n\n [%.2f, %.2f, %.2f]\n\nis too far away from the "
                    "current pose\n\n [%.2f, %.2f, %.2f]",
                    pair.second->rtStatusInNonRT.desiredPose(0, 3),
                    pair.second->rtStatusInNonRT.desiredPose(1, 3),
                    pair.second->rtStatusInNonRT.desiredPose(2, 3),
                    pair.second->rtStatusInNonRT.currentPose(0, 3),
                    pair.second->rtStatusInNonRT.currentPose(1, 3),
                    pair.second->rtStatusInNonRT.currentPose(2, 3))
                    .deactivateSpam(1.0);
            }
        }
    }
 
    void
    NJointTaskspaceMixedImpedanceVelocityController::limbRT(ArmPtr& arm, const double deltaT)
    {
        double timeMeasure = IceUtil::Time::now().toMicroSecondsDouble();
        arm->rtConfig = arm->bufferConfigNonRtToRt.getUpToDateReadBuffer();
        double time_update_non_rt_buffer =
            IceUtil::Time::now().toMicroSecondsDouble() - timeMeasure;
 
        if (arm->rtFirstRun.load())
        {
            arm->controller.ftsensor.reset();
        }
        else
        {
            arm->controller.updateFT(arm->rtConfig.ftConfig, arm->rtStatus);
        }
        double time_update_ft = IceUtil::Time::now().toMicroSecondsDouble() - timeMeasure;
 
        size_t nDoF = arm->sensorDevices.positionSensors.size();
        double time_update_size = IceUtil::Time::now().toMicroSecondsDouble() - timeMeasure;
        for (size_t i = 0; i < nDoF; ++i)
        {
            arm->rtStatus.jointPosition[i] = arm->sensorDevices.positionSensors[i]->position;
            arm->rtStatus.jointVelocity[i] = arm->sensorDevices.velocitySensors[i]->velocity;
            arm->rtStatus.jointTorque[i] = arm->sensorDevices.torqueSensors[i]->torque;
        }
 
        double time_update_js = IceUtil::Time::now().toMicroSecondsDouble() - timeMeasure;
        arm->rtStatus.deltaT = deltaT;
        double time_update_rt_status = IceUtil::Time::now().toMicroSecondsDouble() - timeMeasure;
 
        arm->bufferRtStatusToNonRt.getWriteBuffer() = arm->rtStatus;
        arm->bufferRtStatusToNonRt.commitWrite();
        arm->bufferRtStatusToUser.getWriteBuffer() = arm->rtStatus;
        arm->bufferRtStatusToUser.commitWrite();
        double time_write_rt_buffer = IceUtil::Time::now().toMicroSecondsDouble() - timeMeasure;
 
        arm->controller.run(arm->rtConfig, arm->rtStatus);
        double time_run_rt = IceUtil::Time::now().toMicroSecondsDouble() - timeMeasure;
 
        for (unsigned int i = 0; i < arm->rtStatus.nDoFTorque; i++)
        {
            auto jointIdx = arm->controller.jointIDTorqueMode[i];
            arm->targetsTorque.at(i)->torque = arm->rtStatus.desiredJointTorques(jointIdx);
            if (!arm->targetsTorque.at(i)->isValid())
            {
                arm->targetsTorque.at(i)->torque = 0;
            }
        }
        for (unsigned int i = 0; i < arm->rtStatus.nDoFVelocity; i++)
        {
            auto jointIdx = arm->controller.jointIDVelocityMode[i];
            arm->targetsVel.at(i)->velocity = arm->rtStatus.desiredJointVelocity(jointIdx);
            // if (!targets.at(i)->isValid() || fabs(targets.at(i)->velocity) > cfg->maxJointVelocity)
            if (!arm->targetsVel.at(i)->isValid())
            {
                arm->targetsVel.at(i)->velocity = 0;
            }
        }
        arm->bufferRtStatusToOnPublish.getWriteBuffer() = arm->rtStatus;
        arm->bufferRtStatusToOnPublish.commitWrite();
 
        arm->bufferConfigRtToOnPublish.getWriteBuffer() = arm->rtConfig;
        arm->bufferConfigRtToOnPublish.commitWrite();
 
        arm->bufferConfigRtToUser.getWriteBuffer() = arm->rtConfig;
        arm->bufferConfigRtToUser.commitWrite();
        double time_rt_status_buffer = IceUtil::Time::now().toMicroSecondsDouble() - timeMeasure;
        timeMeasure = IceUtil::Time::now().toMicroSecondsDouble() - timeMeasure;
 
        if (timeMeasure > 100)
        {
            ARMARX_RT_LOGF_WARN("---- rt too slow: unit in (us)"
                                "update_non_rt_buffer: %.2f\n"
                                "update_ft: %.2f\n"
                                "update_size: %.2f\n"
                                "update_js: %.2f\n"
                                "update_rt_status: %.2f\n"
                                "write_rt_buffer: %.2f\n"
                                "run_rt: %.2f\n"
                                "rt_status_buffer: %.2f\n"
                                "time all: %.2f\n",
                                time_update_non_rt_buffer, // 0-1 us
                                time_update_ft - time_update_non_rt_buffer, //
                                time_update_size - time_update_ft, //
                                time_update_js - time_update_size, //
                                time_update_rt_status - time_update_non_rt_buffer, // 1-2 us
                                time_write_rt_buffer - time_update_rt_status, // 0-1 us
                                time_run_rt - time_write_rt_buffer, // 26-33 us
                                time_rt_status_buffer - time_run_rt,
                                timeMeasure); // 0-1 us
        }
 
        if (arm->rtFirstRun.load())
        {
            arm->rtFirstRun.store(false);
            arm->rtReady.store(true);
        }
    }
 
    void
    NJointTaskspaceMixedImpedanceVelocityController::rtRun(
        const IceUtil::Time& /*sensorValuesTimestamp*/,
        const IceUtil::Time& timeSinceLastIteration)
    {
        double deltaT = timeSinceLastIteration.toSecondsDouble();
        for (auto& pair : limb)
        {
            limbRT(pair.second, deltaT);
        }
    }
 
    Ice::FloatSeq
    NJointTaskspaceMixedImpedanceVelocityController::getTCPVel(const std::string& rns,
                                                               const Ice::Current& iceCurrent)
    {
        std::vector<float> tcpVel;
        auto& arm = limb.at(rns);
        auto s = arm->bufferRtStatusToUser.getUpToDateReadBuffer();
        for (int i = 0; i < s.currentTwist.size(); i++)
        {
            tcpVel.push_back(s.currentTwist[i]);
        }
        return tcpVel;
    }
 
    void
    NJointTaskspaceMixedImpedanceVelocityController::updateConfig(
        const ::armarx::aron::data::dto::DictPtr& dto,
        const Ice::Current& iceCurrent)
    {
        userConfig.fromAron(dto);
        for (auto& pair : userConfig.cfg)
        {
            validateConfigData(pair.second, limb.at(pair.first));
            limb.at(pair.first)->bufferConfigUserToNonRt.getWriteBuffer() = pair.second;
            limb.at(pair.first)->bufferConfigUserToNonRt.commitWrite();
        }
    }
 
    void
    NJointTaskspaceMixedImpedanceVelocityController::enableSafeGuardForceTorque(
        const std::string& nodeSetName,
        const bool forceGuard,
        const bool torqueGuard,
        const Ice::Current& iceCurrent)
    {
        auto it = userConfig.cfg.find(nodeSetName);
        if (it != userConfig.cfg.end())
        {
            it->second.ftConfig.enableSafeGuardForce = forceGuard;
            it->second.ftConfig.enableSafeGuardTorque = torqueGuard;
            limb.at(nodeSetName)->controller.ftsensor.resetSafeGuardOffset();
            ARMARX_IMPORTANT
                << "reset safe guard with force torque sensors: safe? "
                << limb.at(nodeSetName)->controller.ftsensor.isSafe(it->second.ftConfig);
            limb.at(nodeSetName)->bufferConfigUserToNonRt.getWriteBuffer() = it->second;
            limb.at(nodeSetName)->bufferConfigUserToNonRt.commitWrite();
        }
        else
        {
            ARMARX_WARNING << "no robot node set with name " << nodeSetName
                           << " found in the controllers.";
        }
    }
 
    bool
    NJointTaskspaceMixedImpedanceVelocityController::isSafeForceTorque(
        const std::string& nodeSetName,
        const Ice::Current& iceCurrent)
    {
        auto it = userConfig.cfg.find(nodeSetName);
        if (it != userConfig.cfg.end())
        {
            return limb.at(nodeSetName)->controller.ftsensor.ftSafe.load();
        }
        else
        {
            ARMARX_WARNING << "no robot node set with name " << nodeSetName
                           << " found in the controllers.";
        }
        return false;
    }
 
    bool
    NJointTaskspaceMixedImpedanceVelocityController::updateTargetPose(
        const TargetPoseMap& targetPoseMap,
        const TargetNullspaceMap& targetNullspaceMap,
        const Ice::Current& iceCurrent)
    {
        for (auto& pair : userConfig.cfg)
        {
            for (size_t i = 0; i < 4; ++i)
            {
                for (int j = 0; j < 4; ++j)
                {
                    pair.second.desiredPose(i, j) = targetPoseMap.at(pair.first)[i][j];
                }
            }
            if (targetNullspaceMap.at(pair.first).size() > 0)
            {
                const size_t nDoF = pair.second.desiredNullspaceJointAngles.value().size();
                ARMARX_CHECK_EQUAL(targetNullspaceMap.at(pair.first).size(), nDoF)
                    << "the joint numbers does not match";
                for (size_t i = 0; i < nDoF; ++i)
                {
                    pair.second.desiredNullspaceJointAngles.value()(i) =
                        targetNullspaceMap.at(pair.first)[i];
                }
            }
            limb.at(pair.first)->bufferConfigUserToNonRt.getWriteBuffer() = pair.second;
            limb.at(pair.first)->bufferConfigUserToNonRt.commitWrite();
        }
        return true;
    }
 
    ::armarx::aron::data::dto::DictPtr
    NJointTaskspaceMixedImpedanceVelocityController::getConfig(const Ice::Current& iceCurrent)
    {
        for (auto& pair : limb)
        {
            userConfig.cfg.at(pair.first) =
                pair.second->bufferConfigRtToUser.getUpToDateReadBuffer();
        }
        return userConfig.toAronDTO();
    }
 
    void
    NJointTaskspaceMixedImpedanceVelocityController::validateConfigData(Config& configData,
                                                                        ArmPtr& arm)
    {
        const auto nDoF = arm->controller.numOfJoints;
 
        const auto checkSize = [nDoF](const auto& v) { ARMARX_CHECK_EQUAL(v.rows(), nDoF); };
        const auto checkNonNegative = [](const auto& v) { ARMARX_CHECK((v.array() >= 0).all()); };
 
        if (!configData.desiredNullspaceJointAngles.has_value())
        {
            if (!isControllerActive())
            {
                ARMARX_INFO << "No user defined nullspace target, reset to zero with "
                            << VAROUT(nDoF);
                configData.desiredNullspaceJointAngles = Eigen::VectorXf::Zero(nDoF);
                arm->reInitPreActivate.store(true);
            }
            else
            {
                auto currentValue =
                    arm->bufferConfigRtToUser.getUpToDateReadBuffer().desiredNullspaceJointAngles;
                ARMARX_WARNING
                    << "Controller is active, but no user defined nullspace target. \n"
                       "You should first get up-to-date config of this controller and then update "
                       "it:\n"
                       "    auto cfg = ctrl->getConfig(); \n"
                       "    cfg.desiredPose = xxx;\n"
                       "    ctrl->updateConfig(cfg);\n"
                       "Now, I decide by myself to use the existing values of nullspace target\n"
                    << currentValue.value();
                configData.desiredNullspaceJointAngles = currentValue;
            }
        }
        ARMARX_CHECK_GREATER(configData.safeDistanceToGoal, 100.0f);
        checkSize(configData.desiredNullspaceJointAngles.value());
        checkSize(configData.kdNullspaceTorque);
        checkSize(configData.kpNullspaceTorque);
        checkSize(configData.kdNullspaceVel);
        checkSize(configData.kpNullspaceVel);
 
        checkNonNegative(configData.kdNullspaceTorque);
        checkNonNegative(configData.kpNullspaceTorque);
        checkNonNegative(configData.kpNullspaceVel);
        checkNonNegative(configData.kdNullspaceVel);
        checkNonNegative(configData.kdImpedance);
        checkNonNegative(configData.kpImpedance);
    }
 
    void
    NJointTaskspaceMixedImpedanceVelocityController::limbPublish(
        ArmPtr& arm,
        const DebugObserverInterfacePrx& debugObs)
    {
        StringVariantBaseMap datafields;
        auto rtData = arm->bufferConfigRtToOnPublish.getUpToDateReadBuffer();
        auto rtStatus = arm->bufferRtStatusToOnPublish.getUpToDateReadBuffer();
 
 
        common::debugEigenPose(datafields, "current_pose", rtStatus.currentPose);
        common::debugEigenPose(datafields, "desired_pose", rtStatus.desiredPose);
        common::debugEigenVec(datafields, "kpImpedance", rtData.kpImpedance);
        common::debugEigenVec(datafields, "kdImpedance", rtData.kdImpedance);
 
        common::debugEigenVec(datafields, "currentForceTorque", rtStatus.currentForceTorque);
 
        common::debugEigenVec(datafields, "forceImpedance", rtStatus.forceImpedance);
        common::debugEigenVec(datafields, "cartesianVelTarget", rtStatus.cartesianVelTarget);
        common::debugEigenVec(datafields, "nullspaceTorque", rtStatus.nullspaceTorque);
        common::debugEigenVec(datafields, "desiredJointTorques", rtStatus.desiredJointTorques);
        debugObs->setDebugChannel(getClassName() + "_" + arm->kinematicChainName, datafields);
    }
 
    void
    NJointTaskspaceMixedImpedanceVelocityController::onPublish(
        const SensorAndControl&,
        const DebugDrawerInterfacePrx&,
        const DebugObserverInterfacePrx& debugObs)
    {
        for (auto& pair : limb)
        {
            limbPublish(pair.second, debugObs);
        }
    }
 
    void
    NJointTaskspaceMixedImpedanceVelocityController::calibrateFTSensor(const Ice::Current&)
    {
        for (auto& pair : limb)
        {
            pair.second->rtReady.store(false);
        }
    }
 
    void
    NJointTaskspaceMixedImpedanceVelocityController::limbReInit(ArmPtr& arm)
    {
        VirtualRobot::RobotNodeSetPtr rns = rtGetRobot()->getRobotNodeSet(arm->kinematicChainName);
        Eigen::Matrix4f currentPose = rns->getTCP()->getPoseInRootFrame();
        ARMARX_IMPORTANT << "rt preactivate controller with target pose\n\n" << currentPose;
 
        if (arm->reInitPreActivate.load())
        {
            arm->rtConfig.desiredNullspaceJointAngles.value() = rns->getJointValuesEigen();
            arm->rtConfig.desiredPose = currentPose;
 
            arm->bufferConfigUserToNonRt.reinitAllBuffers(arm->rtConfig);
            arm->reInitPreActivate.store(false);
        }
        {
            arm->nonRtConfig = arm->rtConfig;
            arm->bufferConfigNonRtToRt.reinitAllBuffers(arm->rtConfig);
            arm->bufferConfigRtToOnPublish.reinitAllBuffers(arm->rtConfig);
            arm->bufferConfigRtToUser.reinitAllBuffers(arm->rtConfig);
        }
 
        const auto nDoF = rns->getSize();
        const auto nDoFTorque = arm->controller.jointIDTorqueMode.size();
        const auto nDoFVelocity = arm->controller.jointIDVelocityMode.size();
        {
            arm->rtStatus.nDoFTorque = nDoFTorque;
            arm->rtStatus.nDoFVelocity = nDoFVelocity;
            arm->rtStatus.numJoints = nDoF;
            arm->rtStatus.desiredJointTorques.setZero(nDoF);
            arm->rtStatus.desiredJointVelocity.setZero(nDoF);
            arm->rtStatus.forceImpedance.setZero();
            arm->rtStatus.cartesianVelTarget.setZero();
            arm->rtStatus.nullspaceTorque.setZero(nDoF);
            arm->rtStatus.nullspaceVelocity.setZero(nDoF);
 
            arm->rtStatus.jointPosition.resize(nDoF, 0.);
            arm->rtStatus.jointVelocity.resize(nDoF, 0.);
            arm->rtStatus.jointTorque.resize(nDoF, 0.);
            for (size_t i = 0; i < nDoF; ++i)
            {
                arm->rtStatus.jointPosition[i] = arm->sensorDevices.positionSensors[i]->position;
                arm->rtStatus.jointVelocity[i] = arm->sensorDevices.velocitySensors[i]->velocity;
                arm->rtStatus.jointTorque[i] = arm->sensorDevices.torqueSensors[i]->torque;
            }
 
            arm->rtStatus.qpos = rns->getJointValuesEigen();
            arm->rtStatus.qvel.setZero(nDoF);
            arm->rtStatus.qvelFiltered.setZero(nDoF);
 
            arm->rtStatus.currentPose = currentPose;
            arm->rtStatus.desiredPose = currentPose;
            arm->rtStatus.currentTwist.setZero();
            arm->rtStatus.poseDiffMatImp.setZero();
            arm->rtStatus.poseErrorImp.setZero();
            arm->rtStatus.jacobi.setZero(6, nDoF);
            arm->rtStatus.jtpinv.setZero(6, nDoF);
 
            arm->rtStatus.deltaT = 0.0;
            arm->rtStatus.rtSafe = false;
 
            arm->rtStatus.currentForceTorque.setZero();
 
            arm->rtStatusInNonRT = arm->rtStatus;
            arm->bufferRtStatusToOnPublish.reinitAllBuffers(arm->rtStatus);
            arm->bufferRtStatusToNonRt.reinitAllBuffers(arm->rtStatus);
            arm->bufferRtStatusToUser.reinitAllBuffers(arm->rtStatus);
        }
 
        arm->controller.preactivateInit(rns);
    }
 
    void
    NJointTaskspaceMixedImpedanceVelocityController::rtPreActivateController()
    {
        for (auto& pair : limb)
        {
            ARMARX_INFO << "rtPreActivateController for " << pair.first;
            limbReInit(pair.second);
            userConfig.cfg.at(pair.first) = pair.second->rtConfig;
        }
    }
 
    void
    NJointTaskspaceMixedImpedanceVelocityController::rtPostDeactivateController()
    {
        // for (auto& pair : limb)
        // {
        //     pair.second->controller.isInitialized.store(false);
        // }
    }
} // namespace armarx::control::njoint_controller::task_space