🍫 👩🏾‍🤝‍👨🏽 🚵🏻 जावास्क्रिप्ट और कम्पास का उपयोग करके आईएसएस को डॉकिंग करना 🧑🏾‍🤝‍🧑🏻 🙍🏾 🏂🏾

स्पेसएक्स कंपनी, कुख्यात इलॉन मास्क द्वारा स्थापित, आईएसएस के साथ क्रू ड्रैगन अंतरिक्ष यान के मैनुअल डॉकिंग के लिए एक सिम्युलेटर जारी किया। यदि सब कुछ योजना के अनुसार हुआ, तो डॉकिंग 27 मई, 2020 को होगी। यह पूरी तरह से स्वचालित मोड में होगा, लेकिन चालक दल मैन्युअल नियंत्रण पर स्विच करने में सक्षम होगा। दरअसल, यह मैनुअल मोड है जिसे सिम्युलेटर में पुन: पेश किया जाता है।

सिम्युलेटर स्वयं साइट पर स्थित है और पहले रिज के लिए एक समस्याग्रस्त खिलौना है ...

अंतरिक्ष शटल गलत तरीके से उड़ान भरने की कोशिश करता है ... और गेटवे में जाने के लिए आपको जिस सटीकता की आवश्यकता होती है वह 20 सेमी है ... तीन अक्षों के साथ-साथ कोणीय वेग, विस्थापन की गति। आदि।

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

आप कैसे पसंद करते हैं, एलोन मस्क?

धूम्रपान आपके स्वास्थ्य के लिए बुरा है

ध्यान! यह एल्गोरिथ्म "भोज" है, और वास्तविक परिस्थितियों में उपयोग के लिए अभिप्रेत नहीं था। इस एल्गोरिथ्म का उपयोग करके आपके अंतरिक्ष यान या अन्य वस्तुओं द्वारा किए गए किसी भी प्रत्यक्ष या अप्रत्यक्ष नुकसान के लिए लेखक जिम्मेदार नहीं है।

पहला, थोड़ा इतिहास।

यह एक सर्वविदित तथ्य है कि हमारा पुन: प्रयोज्य अंतरिक्ष यान बुरान एक अमेरिकी शटल के समान था। और यह भी ज्ञात है कि उन्होंने अमेरिकी "समकक्षों" के विपरीत केवल एक बार उड़ान भरी। लेकिन कम ही लोग जानते हैं कि उनकी एकमात्र उड़ान मानव रहित थी। उसने खुद को उतार दिया, वह उतरा और उसने बहुत खराब मौसम की स्थिति में यह सब किया।

अमेरिकन शुटल हमेशा मैनुअल मोड में ही उतरते थे। यह आश्चर्य की बात है कि कंप्यूटर एक कैलकुलेटर से अधिक शक्तिशाली नहीं हुआ करते थे। यह, सिद्धांत रूप में, यह मुश्किल नहीं होना चाहिए, कल रात सोचा था।

लेकिन चलिए मुद्दे पर आते हैं। स्पेसएक्स वेबसाइट पर एक सिम्युलेटर क्या है ।

शुरुआत में, हम सामान्य जानकारी देखते हैं कि सभी मापदंडों में विचलन 0.2 मीटर (20 सेमी) के भीतर होना चाहिए। स्टेशन और जहाज के आकार को देखते हुए, यह एक बहुत गंभीर सीमा है।

हम सिम्युलेटर शुरू करते हैं और देखते हैं।

ऊपर, केंद्रीय सर्कल के नीचे और नीचे तीन अक्षों के साथ जहाज का कोणीय विचलन है।
हरा - वर्तमान मूल्य।

नीला - प्रति सेकंड की गति जिसके साथ यह बदलता है।

गेट में मीटर के सापेक्ष लेफ्ट ऑफसेट। कोई विस्थापन गति नहीं है ...

स्क्रीन के नीचे नियंत्रक कीबोर्ड पर उनके दोहराव के साथ बटन हैं।

इसलिए हम उनके साथ कार्यक्रम के विश्लेषण को सबसे कम दिलचस्प मानते हैं।

कीबोर्ड बटन का लेआउट।

बाएं ब्लॉक गेटवे के सापेक्ष ऑफसेट के लिए जिम्मेदार है, लेकिन अक्षों के सापेक्ष ऑफसेट के लिए सही है।

हम नेटवर्क पर लिखते हैं या पाते हैं, एक कोड जो दस्तावेज़ पर कीबोर्ड क्लिक का अनुकरण कर सकता है। मेरे मामले में, कोड इस तरह दिखता था।

function simulateKey(keyCode, type, modifiers) {
    var evtName = (typeof (type) === "string") ? "key" + type : "keydown";
    var modifier = (typeof (modifiers) === "object") ? modifier : {};

    var event = document.createEvent("HTMLEvents");
    event.initEvent(evtName, true, false);
    event.keyCode = keyCode;

    for (var i in modifiers) {
        event[i] = modifiers[i];
    }
    document.dispatchEvent(event);
}

function keyPress(keyCode) {
    simulateKey(keyCode)
    setTimeout(() => simulateKey(keyCode, "up"), 15);
}

हम बटन कोड लिखते हैं:

let _accelerator = 69;
let _brake = 81;
let _translateLeft = 65;
let _translateRigth = 68;
let _translateUp = 87;
let _translateDown = 83;

let _left = 37;
let _rigth = 39;
let _up = 38;
let _down = 40;

let _rollRigth = 105;
let _rollLeft = 103;

किसी भी नियंत्रण प्रणाली में एक चक्र में काम शामिल होता है। चलो इसे सबसे आसान बनाते हैं, 200 मिलीसेकंड की वृद्धि में। हम एक के लिए एक काउंटर का आयोजन करेंगे, हमें अभी भी इसकी आवश्यकता होगी

let index = 0;
function A() {

    index++;
    setTimeout(A, 200);
}

A();

आइए साइट की संरचना पर वापस जाएं।

इसकी दिलचस्प विशेषता यह है कि आईएसएस कैनवास पर खींचा गया है, लेकिन हमारे अंतरिक्ष यान की स्थिति के बारे में जानकारी सामान्य मार्कअप के साथ खींची गई है। ऐसा लगता है कि साइट के डेवलपर्स ने मान लिया है कि ऐसे ही उत्साही लोग होंगे जो खेल को "स्वचालित" करना चाहते हैं और उन्हें ऐसा अवसर देते हैं ... या शायद इसे चिह्नित करके, यह बेवकूफी थी, करना आसान था।

और इसलिए, चलो हमारे अंतरिक्ष यान की स्थिति के बारे में जानकारी प्राप्त करने के लिए कुछ और प्रकाश रेखाएँ जोड़ते हैं।


    let range = parseFloat($("#range .rate").outerText.split(' '));

    let yDistance = parseFloat($("#y-range .distance").outerText.split(' ')[0]);
    let zDistance = parseFloat($("#z-range .distance").outerText.split(' ')[0]);

    let rollError = parseFloat($("#roll .error").outerText);
    let pitchError = parseFloat($("#pitch .error").outerText);
    let yawError = parseFloat($("#yaw .error").outerText);

    let rate = parseFloat($("#rate .rate").outerText.split(' ')[0]);

जैसा कि आप देख सकते हैं, मैंने सब कुछ नहीं निकाला। मैंने केवल ऑफ़सेट मान निकाले हैं, लेकिन मैंने मानों के परिवर्तन की दर नहीं ली है, और यहाँ क्यों ...

वास्तव में, यह एल्गोरिथ्म का तीसरा पुनरावृत्ति है। सबसे पहले, यह एक सरल विकल्प है, जो हर 200 मिलीसेकंड जहाज की स्थिति के बारे में जानकारी लेता है और इसे 0. समायोजित करता है। यह

इस तरह दिखता था।

if (rollError !== -rollSpeed) {
        const rollLimit = (Math.abs(rollError) / 10);
        if (0 < rollError && rollSpeed < rollLimit) {
            keyPress(_rollRigth);
        } else if (rollError < -0 && -rollLimit < rollSpeed) {
            keyPress(_rollLeft);
        }
    }

और वास्तव में, वह काफी कार्यकर्ता थे। विशेष रूप से कोणीय विस्थापन के लिए। और कुल्हाड़ियों के साथ विस्थापन के लिए, मैंने इस विकल्प का उपयोग किया।

   const zLimit = (Math.abs(yawError) / 10);
        if (0 < zDistance && zSpeed < zLimit) {
            keyPress(_translateDown);
        } else if (zDistance < 0 && -1 < zSpeed) {
            keyPress(_translateUp);
        }

प्रत्येक अक्ष के सापेक्ष जहाज के विस्थापन की गति प्रदर्शित नहीं होती है, लेकिन इसकी गणना करना मुश्किल नहीं है।

function carculateSpeed() {
    let yDistance = parseFloat($("#y-range .distance").outerText.split(' ')[0]);
    let zDistance = parseFloat($("#z-range .distance").outerText.split(' ')[0]);

    ySpeed = yPrev - yDistance;
    yPrev = yDistance;

    zSpeed = zPrev - zDistance;
    zPrev = zDistance;
    setTimeout(carculateSpeed, 1000);
}
carculateSpeed();

और यह बहुत सहनशील निकला। क्लासिक प्रतिक्रिया नियंत्रण सर्किट। और जब जहाज आईएसएस से कुछ दूरी पर था, हम अपने आप से काफी आसानी से उड़ गए [जैसा कि मुझे तब लगा था]। लेकिन जहाज के पास ही समस्याएं शुरू हो गईं। वास्तव में, जहाज बहुत सॉसेज था और 0.2 मीटर की सटीकता प्राप्त करना शारीरिक रूप से असंभव था। तथ्य यह है कि हमारे जहाज का मिश्रण हुआ था ... आइए निरंतर अंतरिक्ष (महान सटीकता के साथ) में कहें, लेकिन हमने केवल दसवें भाग को देखा। और निश्चित रूप से, हर 200 मिलीसेकंड पर उन्हें जवाब देने की कोशिश करते हुए, हमें बहुत मजबूत नियामक क्रियाएं मिलीं। हमने मामूली विचलन पर कई बार बटन दबाए हैं। और जहाज के करीब, ऑफसेट मूल्यों को मजबूत करना शुरू हो गया और हमने वास्तव में जहाज को और भी अधिक हिला दिया ... इसके आंदोलन के आयाम में वृद्धि ...

लापता सटीकता लेने के लिए कहीं न कहीं आवश्यक था। इस समस्या को हल करने में दूसरी पुनरावृत्ति में, मैंने खुद ही गति विस्थापन के आधार पर पहले से ही गणना करने की कोशिश की। और हाँ, यह बहुत अच्छी तरह से काम करने के लिए भी लग रहा था, लेकिन इससे आंदोलन के साथ समस्या का समाधान नहीं हुआ ... आंदोलन

की समस्या का सार क्या है? ठीक है, हम बाहरी स्थान में पाते हैं और नियंत्रण बटन पर क्लिक करके हम जहाज को एक विमान या किसी अन्य में त्वरण देते हैं। लेकिन जैसे ही हम बटन जारी करते हैं, आंदोलन बंद नहीं होता है। बाहरी जगह में, वैक्यूम के कारण, कोई प्रतिरोध नहीं है। और जैसे ही हमने एक आवेग दिया (एक बटन दबाकर) जहाज इस गति से आगे बढ़ने लगा ... और इसे किसी तरह रोकने की जरूरत है। सिम्युलेटर में रोकना काफी आसान है - आपको एक रिवर्स आवेग देने की आवश्यकता है।

लेकिन समाधान के दूसरे पुनरावृत्ति पर, त्रुटि की बढ़ी हुई सटीकता ने मुझे गति को समायोजित करने के तरीके के बारे में जवाब नहीं दिया ...

और यहां हमें "कम्पास" की आवश्यकता थी। किसी भी जहाज / पोत के कप्तान को अग्रिम मार्ग की गणना करनी चाहिए। यदि वह बंदरगाह में प्रवेश करने के बाद उसे धीमा करने की आज्ञा देता है, तो वह गहने के खराब होने की संभावना नहीं है। और हमें बस इसकी जरूरत है।

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

    if (index % 5 === 0) {
        calculatePath(roll, rollError);
        calculatePath(pitch, pitchError);
        calculatePath(yaw, yawError);
        calculatePath(y, yDistance);
        calculatePath(z, zDistance);
    }

CarculatePath फ़ंक्शन , उनके वर्तमान विचलन मूल्य के आधार पर, 5 चरणों की गणना करता है जो सिद्धांत में इस विचलन को कम करना चाहिए 0. इस पुनरावृत्ति पर जरूरी नहीं, लेकिन हर बार हमें अपने स्वयं के अधिक विस्तृत ग्रिड में क़ीमती शून्य का दृष्टिकोण करना चाहिए।

function calculatePath(data, value) {
    data.path = [];
    if (data.prev === value) {
        data.speed = 0;
    }
    for (let i = 0; i < 5; i++) {
        if (0 < value + data.speed * (i + 1)) {
            data.speed -= 0.1;
            data.path.push(-1);
        } else if (value + data.speed * (i + 1) < -0) {
            data.speed += 0.1;
            data.path.push(1);
        } else if (i > 0) {
            if (0 < data.speed) {
                data.speed -= 0.1;
                data.path.push(-1);
            } else if (data.speed < 0) {
                data.speed += 0.1;
                data.path.push(1);
            } else {
                data.path.push(0);
            }
        } else {
            data.path.push(0);
        }
    }
    data.prev = value;
}

बस इतना ही, हम हर "बराबर" सेकंड (इंडेक्स% 5 === 0) के मार्ग की गणना करते हैं और अब आपको बस इस कोर्स को करने की आवश्यकता है।


 let rollStep = roll.path[index % 5];
    if (0 < rollStep) {
        keyPress(_rollLeft);
    } else if (rollStep < 0) {
        keyPress(_rollRigth);
    }

    let pitchStep = pitch.path[index % 5];
    if (0 < pitchStep) {
        keyPress(_up);
    } else if (pitchStep < 0) {
        keyPress(_down);
    }

    let yawStep = yaw.path[index % 5];
    if (0 < yawStep) {
        keyPress(_left);
    } else if (yawStep < 0) {
        keyPress(_rigth);
    }

    let yStep = y.path[index % 5];
    if (0 < yStep) {
        keyPress(_translateRigth);
    } else if (yStep < 0) {
        keyPress(_translateLeft);
    }

    let zStep = z.path[index % 5];
    if (0 < zStep) {
        keyPress(_translateUp);
    } else if (zStep < 0) {
        keyPress(_translateDown);
    }

एकमात्र गणना जो पहले पुनरावृत्ति के बाद से बच गई है वह जहाज के लिए दृष्टिकोण है।

यह सब ठीक है, हम अपेक्षाकृत कम गति से आगे बढ़ रहे हैं

    const rangeLimit = Math.min(Math.max((Math.abs(range) / 100), 0.05), 2);
    if (-rate < rangeLimit) {
        keyPress(_accelerator);
    } else if (-rangeLimit < -rate) {
        keyPress(_brake);
    }

स्पॉइलर के तहत पूरा कोड है। आप वेबसाइट iss-sim.spacex.com पर इसके प्रदर्शन को स्वयं देख सकते हैं

पूर्ण कोड

function simulateKey(keyCode, type, modifiers) {
    var evtName = (typeof (type) === "string") ? "key" + type : "keydown";
    var modifier = (typeof (modifiers) === "object") ? modifier : {};

    var event = document.createEvent("HTMLEvents");
    event.initEvent(evtName, true, false);
    event.keyCode = keyCode;

    for (var i in modifiers) {
        event[i] = modifiers[i];
    }
    document.dispatchEvent(event);
}

function keyPress(keyCode) {
    simulateKey(keyCode)
    setTimeout(() => simulateKey(keyCode, "up"), 15);
}

let _accelerator = 69;
let _brake = 81;
let _translateLeft = 65;
let _translateRigth = 68;
let _translateUp = 87;
let _translateDown = 83;

let _left = 37;
let _rigth = 39;
let _up = 38;
let _down = 40;

let _rollRigth = 105;
let _rollLeft = 103;

let index = 0;

roll = {
    path: [0, 0, 0, 0, 0],
    prev: 0,
    speed: 0,
}

pitch = {
    path: [0, 0, 0, 0, 0],
    prev: 0,
    speed: 0,
}

yaw = {
    path: [0, 0, 0, 0, 0],
    prev: 0,
    speed: 0,
}

z = {
    path: [0, 0, 0, 0, 0],
    prev: 0,
    speed: 0,
}

y = {
    path: [0, 0, 0, 0, 0],
    prev: 0,
    speed: 0,
}

function calculatePath(data, value) {
    data.path = [];
    if (data.prev === value) {
        data.speed = 0;
    }
    for (let i = 0; i < 5; i++) {
        if (0 < value + data.speed * (i + 1)) {
            data.speed -= 0.1;
            data.path.push(-1);
        } else if (value + data.speed * (i + 1) < -0) {
            data.speed += 0.1;
            data.path.push(1);
        } else if (i > 0) {
            if (0 < data.speed) {
                data.speed -= 0.1;
                data.path.push(-1);
            } else if (data.speed < 0) {
                data.speed += 0.1;
                data.path.push(1);
            } else {
                data.path.push(0);
            }
        } else {
            data.path.push(0);
        }
    }
    data.prev = value;
}

function A() {
    let range = parseFloat($("#range .rate").textContent.split(' '));

    let yDistance = parseFloat($("#y-range .distance").textContent.split(' ')[0]);
    let zDistance = parseFloat($("#z-range .distance").textContent.split(' ')[0]);

    let rollError = parseFloat($("#roll .error").textContent);
    let pitchError = parseFloat($("#pitch .error").textContent);
    let yawError = parseFloat($("#yaw .error").textContent);

    let rate = parseFloat($("#rate .rate").textContent.split(' ')[0]);

    if (index % 5 === 0) {
        calculatePath(roll, rollError);
        calculatePath(pitch, pitchError);
        calculatePath(yaw, yawError);
        calculatePath(y, yDistance);
        calculatePath(z, zDistance);
    }

    let rollStep = roll.path[index % 5];
    if (0 < rollStep) {
        keyPress(_rollLeft);
    } else if (rollStep < 0) {
        keyPress(_rollRigth);
    }

    let pitchStep = pitch.path[index % 5];
    if (0 < pitchStep) {
        keyPress(_up);
    } else if (pitchStep < 0) {
        keyPress(_down);
    }

    let yawStep = yaw.path[index % 5];
    if (0 < yawStep) {
        keyPress(_left);
    } else if (yawStep < 0) {
        keyPress(_rigth);
    }

    let yStep = y.path[index % 5];
    if (0 < yStep) {
        keyPress(_translateRigth);
    } else if (yStep < 0) {
        keyPress(_translateLeft);
    }

    let zStep = z.path[index % 5];
    if (0 < zStep) {
        keyPress(_translateUp);
    } else if (zStep < 0) {
        keyPress(_translateDown);
    }

    const rangeLimit = Math.min(Math.max((Math.abs(range) / 100), 0.05), 2);
    if (-rate < rangeLimit) {
        keyPress(_accelerator);
    } else if (-rangeLimit < -rate) {
        keyPress(_brake);
    }

    index++;
    setTimeout(A, 200);
}

A();

वास्तव में सब कुछ। पढ़ने के लिए आप सभी का धन्यवाद :)

पुनश्च

हां, मैंने थोड़ा हाईपैन किया और मस्ती की। लेख को गंभीरता से न लें, मैं सिर्फ एक अंतरिक्ष यात्री [या अंतरिक्ष यात्री] की तरह महसूस करना चाहता था, जैसे गगारिन यूरी अलेक्सेविच ... हालांकि यह सर्गेई पावलोविच कोरोलेव के इंजीनियरिंग कार्य की संभावना है , जो दुर्भाग्य से कभी भी उस अंतरिक्ष का दौरा नहीं किया था जिसके बारे में उसने सपना देखा था ...

जावास्क्रिप्ट और कम्पास का उपयोग करके आईएसएस को डॉकिंग करना

पुनश्च

More articles: