Download data/core/components/code/robGravityCompensationMTM.cpp from introvoyz045/sawIntuitiveResearchKit: direct link, hf CLI and curl.
- Browser
- Download file 13.1 kB
-
https://huggingface.co/datasets/introvoyz045/sawIntuitiveResearchKit/resolve/main/data/core/components/code/robGravityCompensationMTM.cpp
- Command line
-
hf download hf://datasets/introvoyz045/sawIntuitiveResearchKit/data/core/components/code/robGravityCompensationMTM.cpp
-
curl -L -o robGravityCompensationMTM.cpp https://huggingface.co/datasets/introvoyz045/sawIntuitiveResearchKit/resolve/main/data/core/components/code/robGravityCompensationMTM.cpp
13.1 kB
| /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ | |
| /* ex: set filetype=cpp softtabstop=4 shiftwidth=4 tabstop=4 cindent expandtab: */ | |
| /* | |
| Author(s): Vincent Hui | |
| Created on: 2018 | |
| (C) Copyright 2018-2023, Johns Hopkins University (JHU), All Rights Reserved. | |
| --- begin cisst license - do not edit --- | |
| This software is provided "as is" under an open source license, with | |
| no warranty. The complete license can be found in license.txt and | |
| http://www.cisst.org/cisst/license.txt. | |
| --- end cisst license --- | |
| */ | |
| robGravityCompensationMTM::robGravityCompensationMTM(const robGravityCompensationMTM::Parameters & parameters, int version) | |
| : mParameters(parameters) | |
| , mRegressor(parameters.JointCount(), parameters.DynamicParameterCount(), 0.0) | |
| , mOnes(parameters.JointCount(), 1.0) | |
| , mGravityEfforts(parameters.JointCount(), 0.0) | |
| , mTauPos(parameters.JointCount(), 0.0) | |
| , mTauNeg(parameters.JointCount(), 0.0) | |
| , mBeta(parameters.JointCount(), 0.0) | |
| , mOneMinusBeta(parameters.JointCount(), 0.0) | |
| , mAlpha(parameters.JointCount(), 0.0) | |
| , mOneMinusAlpha(parameters.JointCount(), 0.0) | |
| , mVersion(version) | |
| {} | |
| void robGravityCompensationMTM::AssignRegressor(const vctVec & q, vctMat & regressor) | |
| { | |
| constexpr double g = 9.81; | |
| const double q1 = q[0]; | |
| const double q2 = q[1]; | |
| const double q3 = q[2]; | |
| const double q4 = q[3]; | |
| const double q5 = q[4]; | |
| const double q6 = q[5]; | |
| const double sq2 = sin(q2); | |
| const double cq2 = cos(q2); | |
| const double sq3 = sin(q3); | |
| const double cq3 = cos(q3); | |
| const double sq4 = sin(q4); | |
| const double cq4 = cos(q4); | |
| const double sq5 = sin(q5); | |
| const double cq5 = cos(q5); | |
| const double sq6 = sin(q6); | |
| const double cq6 = cos(q6); | |
| const double sq2pq3 = sin(q2 + q3); | |
| regressor.Element(0, 10) = 1.0; | |
| regressor.Element(0, 11) = q1; | |
| regressor.Element(0, 12) = q1 * q1; | |
| regressor.Element(0, 13) = q1 * q1 * q1; | |
| regressor.Element(0, 14) = q1 * q1 * q1 * q1; | |
| regressor.Element(1, 0) = g * sq2; | |
| regressor.Element(1, 1) = g * cq2; | |
| regressor.Element(1, 2) = g * cq2 * cq3 - g * sq2 * sq3; | |
| regressor.Element(1, 3) = -g * cq2 * sq3 - g * cq3 * sq2; | |
| regressor.Element(1, 4) = | |
| g * cq2 * cq3 * cq4 - g * cq4 * sq2 * sq3; | |
| regressor.Element(1, 5) = | |
| g * sq2 * sq3 * sq4 - g * cq2 * cq3 * sq4; | |
| regressor.Element(1, 6) = g * cq4 * sq2 * sq3 * sq5 - | |
| g * cq3 * cq5 * sq2 - | |
| g * cq2 * cq3 * cq4 * sq5 - | |
| g * cq2 * cq5 * sq3; | |
| regressor.Element(1, 7) = g * cq2 * cq3 * cq4 * cq5 - | |
| g * cq3 * sq2 * sq5 - | |
| g * cq2 * sq3 * sq5 - | |
| g * cq4 * cq5 * sq2 * sq3; | |
| regressor.Element(1, 8) = g * cq2 * cq3 * sq4 * sq6 + | |
| g * cq2 * cq6 * sq3 * sq5 + | |
| g * cq3 * cq6 * sq2 * sq5 - | |
| g * sq2 * sq3 * sq4 * sq6 + | |
| g * cq4 * cq5 * cq6 * sq2 * sq3 - | |
| g * cq2 * cq3 * cq4 * cq5 * cq6; | |
| regressor.Element(1, 9) = g * cq2 * cq3 * cq6 * sq4 - | |
| g * cq6 * sq2 * sq3 * sq4 - | |
| g * cq2 * sq3 * sq5 * sq6 - | |
| g * cq3 * sq2 * sq5 * sq6 - | |
| g * cq4 * cq5 * sq2 * sq3 * sq6 + | |
| g * cq2 * cq3 * cq4 * cq5 * sq6; | |
| regressor.Element(1, 15) = 1.0; | |
| regressor.Element(1, 16) = q2; | |
| regressor.Element(1, 17) = q2 * q2; | |
| regressor.Element(1, 18) = q2 * q2 * q2; | |
| regressor.Element(1, 19) = q2 * q2 * q2 * q2; | |
| regressor.Element(2, 2) = g * cq2 * cq3 - g * sq2 * sq3; | |
| regressor.Element(2, 3) = -g * cq2 * sq3 - g * cq3 * sq2; | |
| regressor.Element(2, 4) = | |
| g * cq2 * cq3 * cq4 - g * cq4 * sq2 * sq3; | |
| regressor.Element(2, 5) = | |
| g * sq2 * sq3 * sq4 - g * cq2 * cq3 * sq4; | |
| regressor.Element(2, 6) = g * cq4 * sq2 * sq3 * sq5 - | |
| g * cq3 * cq5 * sq2 - | |
| g * cq2 * cq3 * cq4 * sq5 - | |
| g * cq2 * cq5 * sq3; | |
| regressor.Element(2, 7) = g * cq2 * cq3 * cq4 * cq5 - | |
| g * cq3 * sq2 * sq5 - | |
| g * cq2 * sq3 * sq5 - | |
| g * cq4 * cq5 * sq2 * sq3; | |
| regressor.Element(2, 8) = g * cq2 * cq3 * sq4 * sq6 + | |
| g * cq2 * cq6 * sq3 * sq5 + | |
| g * cq3 * cq6 * sq2 * sq5 - | |
| g * sq2 * sq3 * sq4 * sq6 + | |
| g * cq4 * cq5 * cq6 * sq2 * sq3 - | |
| g * cq2 * cq3 * cq4 * cq5 * cq6; | |
| regressor.Element(2, 9) = g * cq2 * cq3 * cq6 * sq4 - | |
| g * cq6 * sq2 * sq3 * sq4 - | |
| g * cq2 * sq3 * sq5 * sq6 - | |
| g * cq3 * sq2 * sq5 * sq6 - | |
| g * cq4 * cq5 * sq2 * sq3 * sq6 + | |
| g * cq2 * cq3 * cq4 * cq5 * sq6; | |
| regressor.Element(2, 20) = 1.0; | |
| regressor.Element(2, 21) = q3; | |
| regressor.Element(2, 22) = q3 * q3; | |
| regressor.Element(2, 23) = q3 * q3 * q3; | |
| regressor.Element(2, 24) = q3 * q3 * q3 * q3; | |
| regressor.Element(3, 4) = -g * sq2pq3 * sq4; | |
| regressor.Element(3, 5) = -g * sq2pq3 * cq4; | |
| regressor.Element(3, 6) = g * sq2pq3 * sq4 * sq5; | |
| regressor.Element(3, 7) = -g * sq2pq3 * cq5 * sq4; | |
| regressor.Element(3, 8) = | |
| g * sq2pq3 * (cq4 * sq6 + cq5 * cq6 * sq4); | |
| regressor.Element(3, 9) = | |
| g * sq2pq3 * (cq4 * cq6 - cq5 * sq4 * sq6); | |
| regressor.Element(3, 25) = 1.0; | |
| regressor.Element(3, 26) = q4; | |
| regressor.Element(3, 27) = q4 * q4; | |
| regressor.Element(3, 28) = q4 * q4 * q4; | |
| regressor.Element(3, 29) = q4 * q4 * q4 * q4; | |
| regressor.Element(4, 6) = | |
| -g * (cq2 * cq3 * sq5 - sq2 * sq3 * sq5 + | |
| cq2 * cq4 * cq5 * sq3 + | |
| cq3 * cq4 * cq5 * sq2); | |
| regressor.Element(4, 7) = | |
| -g * (cq5 * sq2 * sq3 - cq2 * cq3 * cq5 + | |
| cq2 * cq4 * sq3 * sq5 + | |
| cq3 * cq4 * sq2 * sq5); | |
| regressor.Element(4, 8) = g * (cq5 * cq6 * sq2 * sq3 - | |
| cq2 * cq3 * cq5 * cq6 + | |
| cq2 * cq4 * cq6 * sq3 * sq5 + | |
| cq3 * cq4 * cq6 * sq2 * sq5); | |
| regressor.Element(4, 9) = -g * (cq5 * sq2 * sq3 * sq6 - | |
| cq2 * cq3 * cq5 * sq6 + | |
| cq2 * cq4 * sq3 * sq5 * sq6 + | |
| cq3 * cq4 * sq2 * sq5 * sq6); | |
| regressor.Element(4, 30) = 1.0; | |
| regressor.Element(4, 31) = q5; | |
| regressor.Element(4, 32) = q5 * q5; | |
| regressor.Element(4, 33) = q5 * q5 * q5; | |
| regressor.Element(4, 34) = q5 * q5 * q5 * q5; | |
| regressor.Element(5, 8) = g * (cq2 * cq6 * sq3 * sq4 + | |
| cq3 * cq6 * sq2 * sq4 + | |
| cq2 * cq3 * sq5 * sq6 - | |
| sq2 * sq3 * sq5 * sq6 + | |
| cq2 * cq4 * cq5 * sq3 * sq6 + | |
| cq3 * cq4 * cq5 * sq2 * sq6); | |
| regressor.Element(5, 9) = g * (cq2 * cq3 * cq6 * sq5 - | |
| cq2 * sq3 * sq4 * sq6 - | |
| cq3 * sq2 * sq4 * sq6 - | |
| cq6 * sq2 * sq3 * sq5 + | |
| cq2 * cq4 * cq5 * cq6 * sq3 + | |
| cq3 * cq4 * cq5 * cq6 * sq2); | |
| regressor.Element(5, 35) = 1.0; | |
| regressor.Element(5, 36) = q6; | |
| regressor.Element(5, 37) = q6 * q6; | |
| regressor.Element(5, 38) = q6 * q6 * q6; | |
| regressor.Element(5, 39) = q6 * q6 * q6 * q6; | |
| } | |
| vctVec robGravityCompensationMTM::compute(const prmStateJoint& state, vct3 CMN_UNUSED(gravity)) | |
| { | |
| AssignRegressor(state.Position(), mRegressor); | |
| if ( 1 == mVersion ) { | |
| ComputeBetaVel(state.Velocity()); | |
| mOnes.SetAll(1.0); | |
| mOneMinusBeta = mOnes.Subtract(mBeta); | |
| mTauPos.ProductOf(mRegressor, mParameters.Pos).ElementwiseMultiply(mBeta); | |
| mTauNeg.ProductOf(mRegressor, mParameters.Neg).ElementwiseMultiply(mOneMinusBeta); | |
| } else if ( 2 == mVersion ) { | |
| ComputeAlphaVel(state.Velocity()); | |
| mOnes.SetAll(1.0); | |
| mOneMinusAlpha = mOnes.Subtract(mAlpha); | |
| mTauPos.ProductOf(mRegressor, mParameters.Pos).ElementwiseMultiply(mAlpha); | |
| mTauNeg.ProductOf(mRegressor, mParameters.Neg).ElementwiseMultiply(mOneMinusAlpha); | |
| } else { | |
| mTauPos.SetAll(0.0); | |
| mTauNeg.SetAll(0.0); | |
| } | |
| mGravityEfforts.SetAll(0.0); | |
| mGravityEfforts.Add(mTauPos); | |
| mGravityEfforts.Add(mTauNeg); | |
| LimitEfforts(mGravityEfforts); | |
| return mGravityEfforts; | |
| } | |
| void robGravityCompensationMTM::LimitEfforts(vctVec & efforts) const | |
| { | |
| auto end = efforts.end(); | |
| auto effort = efforts.begin(); | |
| auto upper = mParameters.UpperEffortsLimit.begin(); | |
| auto lower = mParameters.LowerEffortsLimit.begin(); | |
| for (; | |
| effort != end; | |
| ++effort, | |
| ++upper, | |
| ++lower) { | |
| if (*effort > *upper) { | |
| *effort = *upper; | |
| } else if (*effort < *lower) { | |
| *effort = *lower; | |
| } | |
| } | |
| } | |
| void robGravityCompensationMTM::ComputeAlphaVel(const vctVec & q_dot) | |
| { | |
| auto end = q_dot.end(); | |
| auto qd = q_dot.begin(); | |
| auto bd_vel = mParameters.DBVel.begin(); | |
| auto sat_vel = mParameters.SatVel.begin(); | |
| auto fric_comp_ratio = mParameters.FricCompRatio.begin(); | |
| auto alpha = mAlpha.begin(); | |
| for (; | |
| qd != end; | |
| ++qd, | |
| ++bd_vel, | |
| ++sat_vel, | |
| ++fric_comp_ratio, | |
| ++alpha) { | |
| if (*qd >= *sat_vel) { | |
| *alpha = 0.5 + 0.5*(*fric_comp_ratio); | |
| } else if (*qd <= -(*sat_vel)) { | |
| *alpha = 0.5 - 0.5*(*fric_comp_ratio); | |
| } else if ( (*qd <= *bd_vel) && (*qd >= -(*bd_vel)) ) { | |
| *alpha = 0.5; | |
| } else if ( (*qd > *bd_vel) && (*qd < *sat_vel) ) { | |
| *alpha = 0.5*(*fric_comp_ratio)*(*qd - *bd_vel)/(*sat_vel - *bd_vel) + 0.5; | |
| } else { | |
| *alpha = -0.5*(*fric_comp_ratio)*((-*qd) - *bd_vel)/(*sat_vel - *bd_vel) + 0.5; | |
| } | |
| } | |
| } | |
| void robGravityCompensationMTM::ComputeBetaVel(const vctVec & q_dot) | |
| { | |
| auto end = q_dot.end(); | |
| auto qd = q_dot.begin(); | |
| auto beta = mBeta.begin(); | |
| auto betaVelAmp = mParameters.BetaVelAmp.begin(); | |
| for (; | |
| qd != end; | |
| ++qd, | |
| ++beta, | |
| ++betaVelAmp) { | |
| if (*qd > *betaVelAmp) { | |
| *beta = 1.0; | |
| } | |
| if (*qd < -(*betaVelAmp)) { | |
| *beta = 0.0; | |
| } else { | |
| *beta = 0.5 + sin(*qd * cmnPI / (2.0 * (*betaVelAmp))) / 2.0; | |
| } | |
| } | |
| } | |
| robGravityCompensationMTM::CreationResult | |
| robGravityCompensationMTM::Create(const Json::Value & jsonConfig) | |
| { | |
| // check version | |
| const int version = (int)std::stod(jsonConfig["version"].asString()); | |
| auto getTuple = [&jsonConfig](const std::string &fieldName) { | |
| auto jarray = jsonConfig["GC_controller"][fieldName]; | |
| if (jarray.empty()) { | |
| std::string errorMessage = std::string("the field name \"") + fieldName + std::string("\" cannot be empty."); | |
| return std::make_tuple(jarray, true, errorMessage); | |
| } | |
| return std::make_tuple(jarray, false, std::string("")); | |
| }; | |
| auto isEmpty = [](const std::tuple<Json::Value, bool, std::string> ¶mTuple) { | |
| return std::get<1>(paramTuple); | |
| }; | |
| auto createReturnValue = [](const std::tuple<Json::Value, bool, std::string> ¶mTuple) { | |
| return robGravityCompensationMTM::CreationResult({nullptr, std::get<2>(paramTuple)}); | |
| }; | |
| robGravityCompensationMTM::Parameters params; | |
| if ( 1 == version) { | |
| GCMTM_GetParam("gc_dynamic_params_pos", params.Pos); | |
| GCMTM_GetParam("gc_dynamic_params_neg", params.Neg); | |
| GCMTM_GetParam("beta_vel_amplitude", params.BetaVelAmp); | |
| GCMTM_GetParam("safe_upper_torque_limit", params.UpperEffortsLimit); | |
| GCMTM_GetParam("safe_lower_torque_limit", params.LowerEffortsLimit); | |
| return {new robGravityCompensationMTM(params,version), "version 1 is still supported but you should recalibrate your MTM for version 2"}; | |
| } | |
| if ( 2 == version) { | |
| GCMTM_GetParam("gc_dynamic_params_pos", params.Pos); | |
| GCMTM_GetParam("gc_dynamic_params_neg", params.Neg); | |
| GCMTM_GetParam("safe_upper_torque_limit", params.UpperEffortsLimit); | |
| GCMTM_GetParam("safe_lower_torque_limit", params.LowerEffortsLimit); | |
| GCMTM_GetParam("db_vel_vec", params.DBVel); | |
| GCMTM_GetParam("sat_vec_vec", params.SatVel); | |
| GCMTM_GetParam("fric_comp_ratio_vec", params.FricCompRatio); | |
| return {new robGravityCompensationMTM(params,version), ""}; | |
| } | |
| return {nullptr, "the version of dynamic parameters is invalid"}; | |
| } | |