🔊 🎅🏼 👩🏻‍💻 हम हेक्सापॉड को पुनर्जीवित करते हैं। भाग दो ⚙️ 👩‍🏫 🚙

एक चलती हेक्सापोड का वीडियो

पिछले प्रकाशन की तुलना में , उसके पूर्ववर्ती अधिक शानदार थे, बड़ी संख्या में फोटो के लिए धन्यवाद। मैं इस मामले में अंतर को भरना चाहता हूं और आपको कुछ वीडियो प्रस्तुत करता हूं जो अपार्टमेंट के आसपास एक रोबोट के एक छोटे परीक्षण ड्राइव को कैप्चर करते हैं।

फोन से ऑपरेटर द्वारा वाई-फाई के माध्यम से रोबोट को नियंत्रित किया जाता है। लेकिन जब आप पहले दो वीडियो देखते हैं, तो आपको यह गलत धारणा मिल सकती है कि हेक्सापॉड में बुद्धिमत्ता है। दुर्भाग्य से, ऐसा नहीं है ...

इसके अलावा, रोबोट को नरम कालीन से नहीं बल्कि फिसलन वाले लिनोलियम से निष्कासित कर दिया गया था, जिसने एक अच्छा परिणाम दिखाया।

हेक्सापॉड आंदोलनों का कार्यान्वयन

जैसा कि पिछले लेख में उल्लेख किया गया था , मोशन क्लास से विरासत में मिली मोशनजोब क्लास और व्युत्पन्न कक्षाएं रोबोट आंदोलनों के कार्यान्वयन के लिए जिम्मेदार हैं । मोशनजॉब वर्ग में केवल एक सार्वजनिक निष्पादन विधि है , जो निष्पादन के लिए दिए गए प्रस्ताव को लॉन्च करती है।

int MotionJob :: निष्पादित (गति * गति)

int MotionJob::execute(Motion* pMotion) {
  if(m_Status == NONE && pMotion != NULL) {
     
     m_pMotion = pMotion;
     m_MotionTime = 0;
     m_TotalTime = m_pMotion->totalTime();
     m_Status = RUNING;
  } else if(pMotion != NULL){
    
    if(m_pMotion->m_pNext != NULL) 
      delete m_pMotion->m_pNext;
      
    m_pMotion->m_pNext = pMotion;
     m_Status = STOPING;
  }
  return S_OK;
}

इसका तर्क बहुत सरल है। एक पैरामीटर के रूप में, यह एक संकेतक को एक ऑब्जेक्ट पर ले जाता है जो आंदोलन की प्रक्रिया का वर्णन करता है। यदि वर्तमान समय में निष्पादन में कोई अन्य आंदोलन नहीं था, तो संकेतित आंदोलन सक्रिय हो जाता है, और यह निष्पादन स्थिति ( RUNA ) में प्रवेश करता है । मामले में जब निष्पादन में पहले से ही कुछ आंदोलन था, हम इसे स्टॉप स्टेट ( STOPING ) में अनुवाद करते हैं , और नए आंदोलन को m_pNext फ़ील्ड में अगले के रूप में दर्ज किया जाता है ।

महत्वपूर्ण: यह सहमति है कि मोशन से विरासत में मिली सभी वस्तुएं गतिशील मेमोरी क्षेत्र ( नए माध्यम से ) में निर्माण करती हैं और गति पूरी होने या रद्द होने के बाद मोशनजोब वर्ग द्वारा मुक्त हो जाती हैं ।

MotionJob वर्ग , से विरासत में मिला जा रहा ajob , औजार ओवरलैप में आंदोलन के सभी जादू onRun विधि है, जो रोबोट के आपरेशन के दौरान एक दिया आवृत्ति के साथ कहा जाता है।

शून्य MotionJob :: onRun ()

void MotionJob::onRun() {

  Vector3D points[FOOTS_COUNT];
  int pose[FOOTS_COUNT][3];
  //    ,  
  if(m_pMotion == NULL)
    return;
  //           ,
  //            .
  //      .
  int res;
  if(m_pMotion->getPose(min(m_MotionTime, m_pMotion->maxTime()), pose) == S_OK) {
     res = m_pGeksapod->_setPose(pose);
  } else if(m_pMotion->getPose(min(m_MotionTime, m_pMotion->maxTime()), points) == S_OK) {
     res = m_pGeksapod->_setPose(points);
  }
  //     
  m_MotionTime += MOTION_JOB_PERIOD;
  //     ,    ,
  //      :
  //   m_TotalTime -     
  if(m_TotalTime > 0) { 
    m_TotalTime -= MOTION_JOB_PERIOD;
    m_TotalTime = max(0,m_TotalTime); 
  }
  //      , 
  //      
  if(m_TotalTime == 0 && m_pMotion->isLooped()) {
     m_Status = STOPING;
  }
  //         
  //          .
  if( (m_MotionTime - m_pMotion->maxTime() >= MOTION_JOB_PERIOD && (!m_pMotion->isLooped() || m_Status == STOPING)) ) { //  
    //      
    Motion* pNextMotion = m_pMotion->m_pNext;
    m_pMotion->m_pNext = NULL;
    delete m_pMotion;
    m_pMotion = NULL;
    //   
    m_Status = NONE;
    execute(pNextMotion);
  } else if(m_MotionTime - m_pMotion->maxTime() >= MOTION_JOB_PERIOD) {
    //      
    //         
    m_MotionTime = 0; 
  }
}

उपरोक्त कोड में इसके काम के बारे में पर्याप्त टिप्पणियां हैं, इसलिए, इसके अलावा, मैं केवल कुछ प्रमुख बिंदुओं पर ध्यान देता हूं:

Motion (Vector3D points[FOOTS_COUNT]), (int pose[FOOTS_COUNT][3]). , . getPose , getPose. _setPose, .
आंदोलन नियमित या चक्रीय हो सकते हैं। एक आंदोलन चक्र के निष्पादन के लिए आवंटित समय अवधि के अंत तक पहुंचने पर सामान्य गति ( मोशन :: मैक्सिमेट () विधि द्वारा लौटा ) तुरंत पूरा हो जाएगा।
चक्रीय आंदोलनों को एक मजबूर रोक के बाद ही पूरा किया जाएगा जो तब होता है जब निष्पादन विधि कहा जाता है (एक शून्य सूचक के साथ कहा जा सकता है), या जब समय के एक सकारात्मक बिंदु को आंदोलन के निष्पादन के लिए आवंटित किया जाता है ( मोशन :: टोटल टाइम () विधि द्वारा लौटाया गया )।

विभिन्न गति विकल्पों का वर्णन करने के लिए निम्न वर्गों को परिभाषित किया गया है:

वर्ग ट्रांसपोजमोशन

class TransPoseMotion: public Motion {
  Vector3D m_Pose0[FOOTS_COUNT];  //  
  Vector3D m_Offset[FOOTS_COUNT];  //  
public:  
  TransPoseMotion(Vector3D begPose[FOOTS_COUNT], Vector3D endPose[FOOTS_COUNT],
        long maxTime, Motion* pNext = NULL);
  int getPose(long time, Vector3D points[FOOTS_COUNT]);
};

वर्ग TransAnglesMotion

class TransAnglesMotion: public Motion {
  char m_Pose0[FOOTS_COUNT][3];
  char m_Offset[FOOTS_COUNT][3];
public:  
  TransAnglesMotion(int begPose[FOOTS_COUNT][3], int endPose[FOOTS_COUNT][3],
        long maxTime, Motion* pNext = NULL);
  int getPose(long actionTime, int pose[FOOTS_COUNT][3]);
};

वर्ग रेखीय भावना

class LinearMotion: public Motion {
  //     ( ) 
  Vector3D m_Pose0[FOOTS_COUNT];
  Vector3D m_Offset; //     
  int m_Heigth;          //   
public:  
  LinearMotion(int heigth, Vector3D pose0[FOOTS_COUNT], Vector3D speed, 
        long maxTime, long totalTime = -1, Motion* pNext = NULL);
  int getPose(long time, Vector3D points[FOOTS_COUNT]);
};

क्लास रोटेटमोशन

class RotateMotion: public Motion {
  //     ( ) 
  Vector3D m_Pose0[FOOTS_COUNT]; 
  Vector3D m_Angles; //     
  int m_Heigth;           //   
public:  
  RotateMotion(int heigth, Vector3D pose0[FOOTS_COUNT], Vector3D rotor, 
        long maxTime, long totalTime = -1, Motion* pNext = NULL);
  int getPose(long time, Vector3D points[FOOTS_COUNT]);
};

ट्रांसपोजमोशन क्लास

TransPoseMotion वर्ग आपको अंगों को एक स्थिति से दूसरे स्थान पर ले जाने की अनुमति देता है। एक ऑब्जेक्ट बनाते समय, बिंदुओं के निर्देशांक और समय की अवधि, जिसके बाद आंदोलन किया जाना चाहिए, वर्ग निर्माता को स्थानांतरित कर दिया जाता है।

TransPoseMotion :: TransPoseMotion (...)

TransPoseMotion::TransPoseMotion(Vector3D begPose[FOOTS_COUNT],
  Vector3D endPose[FOOTS_COUNT], long maxTime, Motion* pNext) : Motion(maxTime, -1, pNext) {
  for(int i = 0; i < FOOTS_COUNT; i++) {
    m_Pose0[i] = begPose[i];
    m_Offset[i] = endPose[i] - begPose[i];
  }
}

प्रत्येक अंग के लिए प्रारंभिक स्थिति और विस्थापन वेक्टर को जानकर, हम आसानी से सरल रेखीय गणना करके 0 से अधिकतम समय तक गेटपॉज विधि में पंजे की नई स्थिति प्राप्त कर सकते हैं ।

int TransPoseMotion :: getPose (...)

int TransPoseMotion::getPose(long time, Vector3D points[FOOTS_COUNT]) {
  for(int i = 0; i < FOOTS_COUNT; i++)
    linearFunc(1.0, m_Offset[i], m_Pose0[i], 1.0*time/m_MaxTime, points[i]);
}

रैखिक संगणनाएँ सहायक फ़ंक्शन रैखिकफुनक को सौंपी जाती हैं, जो फ़ंक्शन के तर्कों के माध्यम से निर्दिष्ट मापदंडों के साथ एक साधारण रैखिक समीकरण है।

शून्य रेखाचित्र (...)

void linearFunc(float a, Vector3D offset, Vector3D p0, float k,  Vector3D& res) {
  res = a*offset*k + p0;
}

TransAnglesMotion क्लास

इस वर्ग का तर्क पिछले एक के समान है। अंतर केवल इतना है कि ट्रांसएंग्लेसमोशन क्लास में , हेक्सापॉड अंगों की स्थिति कोणों के सेट द्वारा निर्धारित की जाती है, जिस पर उसके जोड़ों को झुकना चाहिए, न कि रोबोट पंजे के सिरों के स्थानिक निर्देशांक द्वारा।

TransAnglesMotion :: TransAnglesMotion (...)

TransAnglesMotion::TransAnglesMotion(int begPose[FOOTS_COUNT][3],
  int endPose[FOOTS_COUNT][3], long maxTime, Motion* pNext) : Motion(maxTime, -1, pNext) {
  for(int i = 0; i < FOOTS_COUNT; i++) {
    for(int j = 0; j < 3; j++) {
      m_Pose0[i][j] = begPose[i][j];
      m_Offset[i][j] = endPose[i][j] - begPose[i][j];
    }
  }
}

int TransAnglesMotion :: getPose (...)

int TransAnglesMotion::getPose(long time, int pose[FOOTS_COUNT][3]) {
  for(int i = 0; i < FOOTS_COUNT; i++) {
    for(int j = 0; j < 3; j++) 
      pose[i][j] = m_Pose0[i][j] + (int)(1.0*m_Offset[i][j]*time/m_MaxTime);
  }
  return S_OK;
}

लीनियरमोशन क्लास

सीधे गति को लागू करने के लिए थोड़ा अधिक कोड और आपका ध्यान आवश्यक है। हेक्सापॉड डिजाइन में अंगों की एक इष्टतम संख्या है, जो चलते समय आपको हमेशा तीन बिंदुओं का समर्थन करने की अनुमति देती है, ताकि रोबोट के द्रव्यमान के केंद्र का प्रक्षेपण हमेशा उनके द्वारा गठित त्रिकोण के अंदर स्थित हो। यह चलते समय रोबोट की एक स्थिर स्थिति सुनिश्चित करता है। इसलिए, रोबोट के आयताकार आंदोलन को समान चरणों के एक सेट के रूप में माना जा सकता है। ऐसे प्रत्येक चरण में, दो चरणों को प्रतिष्ठित किया जा सकता है। पहले चरण में, पैरों की एक त्रय सतह को छूती है और उनके छोर आंदोलन की दिशा के विपरीत दिशा में सतह के समानांतर चलते हैं। इस मामले में, पंजे का दूसरा त्रैमासिक सतह को छूने के बिना, रोबोट की गति की दिशा में एक घुमावदार पथ के साथ चलता है।एक निश्चित समय पर, वे अपने चरम स्थान पर पहुँच जाते हैं, और दूसरी त्रिक सतह के संपर्क में आने लगते हैं। दूसरे चरण में, गति की प्रक्रिया को दोहराया जाता है, केवल इस बार दूसरा त्रैमासिक रोबोट चलता है, और शुरुआती बिंदु पर पहला रिटर्न देता है।

इस पृष्ठ पर इंटरनेट पर एक लेख तैयार करते समय यह एनीमेशन पाया गया था , लेकिन इसकी समीक्षा करने के बाद मुझे विश्वास हो गया कि इसका मूल स्रोत हब्र था , और प्रकाशन का लेखक सम्मानित कोंकॉर्ड था ।

आंदोलन को एक सीधी रेखा में साकार करते समय, हमें सतह ( एड़ी ) से पैरों की ऊंचाई निर्धारित करने की आवश्यकता होती है, आंदोलन की शुरुआत में (और अंत में) रोबोट अंगों की स्थिति ( pose0 ), वेग वेक्टर ( गति ), एक कदम पूरा करने में लगने वाला समय ( अधिकतम समय ), और रोबोट को कितनी देर तक चलना चाहिए आंदोलन (प्रदर्शन totalTime )। आप के लिए एक नकारात्मक मूल्य निर्दिष्ट करते हैं totalTimeजब तक रोबोट का चार्ज खत्म नहीं हो जाता या आंदोलन जबरन पूरा नहीं हो जाता, तब तक यह आंदोलन अनिश्चित काल तक जारी रहेगा।

लीनियरमोशन :: लीनियरमोशन (...)

LinearMotion::LinearMotion(int heigth, Vector3D pose0[FOOTS_COUNT], Vector3D speed,
  long maxTime, long totalTime, Motion* pNext = NULL) 
    : Motion(maxTime, true, totalTime, pNext) {
  copyPose(m_Pose0, pose0);
  m_Offset = 1.0*speed*maxTime/1000;
  m_Heigth = heigth;
}

इस तथ्य के बावजूद कि गेटपॉज विधि में एक प्रभावशाली मात्रा में कोड है, यह काफी सरल है।

इंट लीनियरमोशन :: getPose (...)

int LinearMotion::getPose(long time, Vector3D points[FOOTS_COUNT]) {
  double k = 1.0*time/m_MaxTime;

  if(k < 0.25) {  //   
    linearFunc(2.0, -m_Offset, m_Pose0[LEFT_FRONT_FOOT_IDX], k,
      points[LEFT_FRONT_FOOT_IDX]);
    linearFunc(2.0, -m_Offset, m_Pose0[LEFT_BACK_FOOT_IDX], k,
      points[LEFT_BACK_FOOT_IDX]);
    linearFunc(2.0, -m_Offset, m_Pose0[RIGTH_MIDLE_FOOT_IDX], k,
      points[RIGTH_MIDLE_FOOT_IDX]);

    linearFunc(2.0, m_Offset, m_Pose0[LEFT_MIDLE_FOOT_IDX], k,
      points[LEFT_MIDLE_FOOT_IDX]);
    linearFunc(2.0, m_Offset, m_Pose0[RIGTH_FRONT_FOOT_IDX], k,
      points[RIGTH_FRONT_FOOT_IDX]);
    linearFunc(2.0, m_Offset, m_Pose0[RIGTH_BACK_FOOT_IDX], k,
      points[RIGTH_BACK_FOOT_IDX]);
  
    int h = (int)m_Heigth*cos(M_PI*k*2);
    points[LEFT_MIDLE_FOOT_IDX].z += h;
    points[RIGTH_FRONT_FOOT_IDX].z += h;
    points[RIGTH_BACK_FOOT_IDX].z += h;

  } else if(k < 0.5) { //   
    
    linearFunc(2.0, m_Offset, m_Pose0[LEFT_FRONT_FOOT_IDX], k - 0.5,
      points[LEFT_FRONT_FOOT_IDX]);
    linearFunc(2.0, m_Offset, m_Pose0[LEFT_BACK_FOOT_IDX], k - 0.5,
      points[LEFT_BACK_FOOT_IDX]);
    linearFunc(2.0, m_Offset, m_Pose0[RIGTH_MIDLE_FOOT_IDX], k - 0.5,
      points[RIGTH_MIDLE_FOOT_IDX]);

    linearFunc(2.0, -m_Offset, m_Pose0[LEFT_MIDLE_FOOT_IDX], k - 0.5,
      points[LEFT_MIDLE_FOOT_IDX]);
    linearFunc(2.0, -m_Offset, m_Pose0[RIGTH_FRONT_FOOT_IDX], k - 0.5,
      points[RIGTH_FRONT_FOOT_IDX]);
    linearFunc(2.0, -m_Offset, m_Pose0[RIGTH_BACK_FOOT_IDX], k - 0.5,
      points[RIGTH_BACK_FOOT_IDX]);

    int h = (int)m_Heigth*sin(M_PI*(k - 0.25)*2);
    points[LEFT_FRONT_FOOT_IDX].z += h;
    points[LEFT_BACK_FOOT_IDX].z += h;
    points[RIGTH_MIDLE_FOOT_IDX].z += h;

  } else if(k < 0.75) { //   
    
    linearFunc(2.0, m_Offset, m_Pose0[LEFT_FRONT_FOOT_IDX], k - 0.5,
      points[LEFT_FRONT_FOOT_IDX]);
    linearFunc(2.0, m_Offset, m_Pose0[LEFT_BACK_FOOT_IDX], k - 0.5,
      points[LEFT_BACK_FOOT_IDX]);
    linearFunc(2.0, m_Offset, m_Pose0[RIGTH_MIDLE_FOOT_IDX], k - 0.5,
      points[RIGTH_MIDLE_FOOT_IDX]);

    linearFunc(2.0, -m_Offset, m_Pose0[LEFT_MIDLE_FOOT_IDX], k - 0.5,
      points[LEFT_MIDLE_FOOT_IDX]);
    linearFunc(2.0, -m_Offset, m_Pose0[RIGTH_FRONT_FOOT_IDX], k - 0.5,
      points[RIGTH_FRONT_FOOT_IDX]);
    linearFunc(2.0, -m_Offset, m_Pose0[RIGTH_BACK_FOOT_IDX], k - 0.5,
      points[RIGTH_BACK_FOOT_IDX]);
    
    int h = (int)m_Heigth*cos(M_PI*(k - 0.5)*2);
    points[LEFT_FRONT_FOOT_IDX].z += h;
    points[LEFT_BACK_FOOT_IDX].z += h;
    points[RIGTH_MIDLE_FOOT_IDX].z += h;
    
  } else {  //   
    
    linearFunc(2.0, m_Offset, m_Pose0[LEFT_FRONT_FOOT_IDX], 1 - k,
      points[LEFT_FRONT_FOOT_IDX]);
    linearFunc(2.0, m_Offset, m_Pose0[LEFT_BACK_FOOT_IDX], 1 - k,
      points[LEFT_BACK_FOOT_IDX]);
    linearFunc(2.0, m_Offset, m_Pose0[RIGTH_MIDLE_FOOT_IDX], 1 - k,
      points[RIGTH_MIDLE_FOOT_IDX]);

    linearFunc(2.0, -m_Offset, m_Pose0[LEFT_MIDLE_FOOT_IDX], 1 - k,
      points[LEFT_MIDLE_FOOT_IDX]);
    linearFunc(2.0, -m_Offset, m_Pose0[RIGTH_FRONT_FOOT_IDX], 1 - k,
      points[RIGTH_FRONT_FOOT_IDX]);
    linearFunc(2.0, -m_Offset, m_Pose0[RIGTH_BACK_FOOT_IDX], 1 - k,
      points[RIGTH_BACK_FOOT_IDX]);
    
    int h = (int)m_Heigth*sin(M_PI*(k - 0.75)*2);
    points[LEFT_MIDLE_FOOT_IDX].z += h;
    points[RIGTH_FRONT_FOOT_IDX].z += h;
    points[RIGTH_BACK_FOOT_IDX].z += h;
  }

  return S_OK;
}

हम पूरे चरण को चार तिमाहियों में विभाजित करते हैं:

पहले त्रैमासिक में, अंगों की पहली त्रय (बाएं सामने, बाएं पीछे और दाएं मध्य) एक धक्का आंदोलन करते हैं, अर्थात, वे सतह के साथ विपरीत दिशा में आंदोलन करते हैं। पंजे की दूसरी तिकड़ी (दाएं सामने, दाएं पीठ और बाएं मध्य) आंदोलन की दिशा में चलती है, जबकि उनके उदय की ऊंचाई पैरों के निर्दिष्ट ऊंचाई (तिमाही की शुरुआत में) से अधिकतम (तिमाही के अंत में) साइन के एक समारोह के रूप में भिन्न होती है।
दूसरी तिमाही में, तीनों की दिशाएं बदल जाती हैं। अब पंजे की दूसरी तिकड़ी रोबोट को ले जाती है, और पहली चाल रोबोट की तरह चलती है। इस मामले में, पहले त्रय के पंजे की ऊंचाई एक साइनसॉइड में शून्य से अधिकतम मूल्य तक बदल जाती है।
तीसरी तिमाही में, पंजे की गति की दिशा बनाए रखी जाती है, और पहले त्रैमासिक के छोर नीचे जाते हैं, तीसरी तिमाही के अंत में सतह तक पहुंचते हैं।
अंतिम तिमाही में, पहला त्रय समर्थन बन जाता है, और दूसरी दिशा बदल जाती है और साइनसॉइड के साथ ऊपर की ओर बढ़ती है, जो तिमाही के अंत में अधिकतम ऊंचाई तक पहुंचती है।

रोटेटमोशन क्लास

लिनियरमोशन क्लास के तर्क को समझने के बाद , हम आसानी से रोटेटमोशन क्लास के कार्यान्वयन का पता लगा सकते हैं ।

RotateMotion :: RotateMotion (...)

RotateMotion::RotateMotion(int heigth, Vector3D pose0[FOOTS_COUNT], Vector3D speed,
  long maxTime, long totalTime = -1, Motion* pNext = NULL) 
    : Motion(maxTime, true, totalTime, pNext) {
  copyPose(m_Pose0, pose0);
  m_Angles = 0.001*maxTime*speed*M_PI/180;
  m_Heigth = heigth;
}

पारित किए गए तर्कों की संरचना में दोनों वर्गों के निर्माता लगभग समान हैं। केवल गति के उलट होने की स्थिति में कोणीय वेग वेक्टर है जो रोबोट के रोटेशन की धुरी और गति को परिभाषित करता है। रोटेटमोशन क्लास

की गेटपॉज विधि में , कार्य का तर्क भी चार चरणों में विभाजित किया गया है। हालांकि, पंजे की स्थिति की गणना करने के लिए, रैखिक फ़ंक्शन रैखिकफंक के बजाय , रेडियल फ़ंक्शन रोटफुनक का उपयोग किया जाता है ।

int RotateMotion :: getPose (...)

int RotateMotion::getPose(long time, Vector3D points[FOOTS_COUNT]) {
  double k = 1.0*time/m_MaxTime;
  if(k < 0.25) {  //   

    rotFunc(2.0, m_Angles, m_Pose0[LEFT_FRONT_FOOT_IDX], k,
      points[LEFT_FRONT_FOOT_IDX]);
    rotFunc(2.0, m_Angles, m_Pose0[LEFT_BACK_FOOT_IDX], k,
      points[LEFT_BACK_FOOT_IDX]);
    rotFunc(2.0, m_Angles, m_Pose0[RIGTH_MIDLE_FOOT_IDX], k,
      points[RIGTH_MIDLE_FOOT_IDX]);
      
    rotFunc(2.0, m_Angles, m_Pose0[LEFT_MIDLE_FOOT_IDX], -k,
      points[LEFT_MIDLE_FOOT_IDX]);
    rotFunc(2.0, m_Angles, m_Pose0[RIGTH_FRONT_FOOT_IDX], -k,
      points[RIGTH_FRONT_FOOT_IDX]);
    rotFunc(2.0, m_Angles, m_Pose0[RIGTH_BACK_FOOT_IDX], -k,
      points[RIGTH_BACK_FOOT_IDX]);

    int h = (int)m_Heigth*cos(M_PI*k*2);
    points[LEFT_MIDLE_FOOT_IDX].z += h;
    points[RIGTH_FRONT_FOOT_IDX].z += h;
    points[RIGTH_BACK_FOOT_IDX].z += h;

  } else if(k < 0.5) {  //   
    
    rotFunc(2.0, m_Angles, m_Pose0[LEFT_FRONT_FOOT_IDX], 0.5 - k,
      points[LEFT_FRONT_FOOT_IDX]);
    rotFunc(2.0, m_Angles, m_Pose0[LEFT_BACK_FOOT_IDX], 0.5 - k,
      points[LEFT_BACK_FOOT_IDX]);
    rotFunc(2.0, m_Angles, m_Pose0[RIGTH_MIDLE_FOOT_IDX], 0.5 - k,
      points[RIGTH_MIDLE_FOOT_IDX]);
      
    rotFunc(2.0, m_Angles, m_Pose0[LEFT_MIDLE_FOOT_IDX], k - 0.5,
      points[LEFT_MIDLE_FOOT_IDX]);
    rotFunc(2.0, m_Angles, m_Pose0[RIGTH_FRONT_FOOT_IDX], k - 0.5,
      points[RIGTH_FRONT_FOOT_IDX]);
    rotFunc(2.0, m_Angles, m_Pose0[RIGTH_BACK_FOOT_IDX], k - 0.5,
      points[RIGTH_BACK_FOOT_IDX]);
  
    int h = (int)m_Heigth*sin(M_PI*(k - 0.25)*2);
    points[LEFT_FRONT_FOOT_IDX].z += h;
    points[LEFT_BACK_FOOT_IDX].z += h;
    points[RIGTH_MIDLE_FOOT_IDX].z += h;

  } else if(k < 0.75) {  //   
  
    rotFunc(2.0, m_Angles, m_Pose0[LEFT_FRONT_FOOT_IDX], 0.5 - k,
      points[LEFT_FRONT_FOOT_IDX]);
    rotFunc(2.0, m_Angles, m_Pose0[LEFT_BACK_FOOT_IDX], 0.5 - k,
      points[LEFT_BACK_FOOT_IDX]);
    rotFunc(2.0, m_Angles, m_Pose0[RIGTH_MIDLE_FOOT_IDX], 0.5 - k,
      points[RIGTH_MIDLE_FOOT_IDX]);
      
    rotFunc(2.0, m_Angles, m_Pose0[LEFT_MIDLE_FOOT_IDX], k - 0.5,
      points[LEFT_MIDLE_FOOT_IDX]);
    rotFunc(2.0, m_Angles, m_Pose0[RIGTH_FRONT_FOOT_IDX], k - 0.5,
      points[RIGTH_FRONT_FOOT_IDX]);
    rotFunc(2.0, m_Angles, m_Pose0[RIGTH_BACK_FOOT_IDX], k - 0.5,
      points[RIGTH_BACK_FOOT_IDX]);
  
    int h = (int)m_Heigth*cos(M_PI*(k - 0.5)*2);
    points[LEFT_FRONT_FOOT_IDX].z += h;
    points[LEFT_BACK_FOOT_IDX].z += h;
    points[RIGTH_MIDLE_FOOT_IDX].z += h;
  } else { //   
    rotFunc(2.0, m_Angles, m_Pose0[LEFT_FRONT_FOOT_IDX], k - 1,
      points[LEFT_FRONT_FOOT_IDX]);
    rotFunc(2.0, m_Angles, m_Pose0[LEFT_BACK_FOOT_IDX], k - 1,
      points[LEFT_BACK_FOOT_IDX]);
    rotFunc(2.0, m_Angles, m_Pose0[RIGTH_MIDLE_FOOT_IDX], k - 1,
      points[RIGTH_MIDLE_FOOT_IDX]);
      
    rotFunc(2.0, m_Angles, m_Pose0[LEFT_MIDLE_FOOT_IDX], 1 - k,
      points[LEFT_MIDLE_FOOT_IDX]);
    rotFunc(2.0, m_Angles, m_Pose0[RIGTH_FRONT_FOOT_IDX], 1 - k,
      points[RIGTH_FRONT_FOOT_IDX]);
    rotFunc(2.0, m_Angles, m_Pose0[RIGTH_BACK_FOOT_IDX], 1 - k,
      points[RIGTH_BACK_FOOT_IDX]);

    int h = (int)m_Heigth*sin(M_PI*(k - 0.75)*2);
    points[LEFT_MIDLE_FOOT_IDX].z += h;
    points[RIGTH_FRONT_FOOT_IDX].z += h;
    points[RIGTH_BACK_FOOT_IDX].z += h;
  }
  return S_OK;
}

रेडियल फ़ंक्शन आपको रोबोट के केंद्र के चारों ओर घूमने के बाद अंतरिक्ष में एक बिंदु की स्थिति की गणना करने की अनुमति देता है, जो मूल के साथ मेल खाता है।

शून्य सड़ना (...)

void rotFunc(float a, Vector3D angles, Vector3D p0, float k, Vector3D& res) {
  Matrix3D m = rotMatrix2(a*angles*k);
  res = m*p0;
}

फ़ंक्शन के अंदर, एक गणितीय उपकरण शामिल है, जिससे हमें वेक्टर और मैट्रिक्स मात्रा के साथ काम करने की अनुमति मिलती है।

अभी के लिए बस इतना ही। हमने रोबोट के आंदोलन को लागू करने के लिए जिम्मेदार प्रोग्राम कोड के एक आवश्यक हिस्से का विश्लेषण किया है। यदि आपके कोई प्रश्न या टिप्पणी हैं, तो मुझे टिप्पणियों में उनका उत्तर देने में खुशी होगी। मैं निम्नलिखित लेख को शेष कोड के लिए समर्पित करने की कोशिश करूंगा, जो स्रोत कोड डाउनलोड के लिए उपलब्ध होगा।
ध्यान देने के लिए आपको धन्यवाद!

जारी रहती है…