रोबोट-विशिष्ट पायथन#

परिचय #

हीरो बॉट, फ्लेक्स में एक क्लॉ मोटर, एक आर्म मोटर, एक एआई विजन सेंसर, एक डिस्टेंस सेंसर और एक गेम पोजिशनिंग सिस्टम (जीपीएस) सेंसर शामिल हैं।

सभी मानक VEXcode VR विधियाँ V5 26-27 ओवरराइड प्लेग्राउंड में उपयोग के लिए उपलब्ध हैं।

नीचे रोबोट-विशिष्ट सभी उपलब्ध विधियों की सूची दी गई है:

ड्राइवट्रेन – रोबोट को गति देने और मोड़ने का कार्य करता है।

कार्यवाही
- drive — रोबोट को हमेशा के लिए आगे या पीछे ले जाता है।
- drive_for — रोबोट को एक विशिष्ट दूरी के लिए आगे या पीछे ले जाता है।
- turn — रोबोट को हमेशा के लिए बाएँ या दाएँ घुमाता है।
- turn_for — रोबोट को एक विशिष्ट संख्या में डिग्री के लिए बाएँ या दाएँ घुमाता है।
- turn_to_heading — रोबोट को -359 से 359 डिग्री तक एक विशिष्ट हेडिंग का सामना करने के लिए मोड़ता है।
- turn_to_rotation — रोबोट को एक विशिष्ट रोटेशन में घुमाता है।
- stop — रोबोट की गति को रोकता है।
म्यूटेटर्स
- set_heading — रोबोट की वर्तमान दिशा को नई दिशा में बदलता है।
- set_rotation — रोबोट के वर्तमान रोटेशन को नए रोटेशन में बदलता है।
- set_timeout — यह निर्धारित करता है कि रोबोट किसी गतिविधि को पूरा करने के लिए कितना समय लेगा।
- set_drive_velocity — रोबोट को बताता है कि कितनी तेज़ी से ड्राइव करना है।
- set_turn_velocity — रोबोट को बताता है कि कितनी तेज़ी से मुड़ना है।
गेटर्स
- heading — रोबोट की वर्तमान हेडिंग 0 से 359.99 डिग्री तक लौटाता है।
- rotation — रोबोट का वर्तमान रोटेशन लौटाता है।
- is_done — यह बताता है कि रोबोट चलना समाप्त कर चुका है या नहीं, बूलियन मान के रूप में।
- is_moving — यह बताता है कि रोबोट चल रहा है या नहीं, बूलियन मान के रूप में।
- velocity — रोबोट कितनी तेज़ी से चल रहा है, यह लौटाता है।

गति – रोबोट के मोटरों को चलाएं और उनकी गति का पता लगाएं।

कार्यवाही
- spin — मोटर को हमेशा के लिए आगे या पीछे घुमाता है।
- spin_for — एक मोटर को एक विशिष्ट दूरी के लिए घुमाता है।
- spin_to_position — मोटर को एक विशिष्ट स्थिति में घुमाता है।
- stop — मोटर को घूमने से रोकता है।
म्यूटेटर्स
- set_position — मोटर की वर्तमान स्थिति को एक नए मान में बदलता है।
- set_velocity — मोटर को बताता है कि कितनी तेज़ी से घूमना है।
- set_timeout — यह निर्धारित करता है कि मोटर किसी गति को पूरा करने के लिए कितना समय प्रयास करेगी।
गेटर्स
- is_done — बूलियन मान के रूप में मोटर चलना समाप्त हो गया है या नहीं, लौटाता है।
- is_spinning — बूलियन मान के रूप में मोटर घूम रही है या नहीं, यह लौटाता है।
- position — मोटर की वर्तमान स्थिति लौटाता है।
- velocity — मोटर कितनी तेज़ी से घूम रही है, यह लौटाता है।

एआई विज़न – एआई विज़न सेंसर का उपयोग करके वस्तुओं को कैप्चर और विश्लेषण करें।

गेटर्स
- take_snapshot – एक विशिष्ट हस्ताक्षर के लिए पता लगाए गए ऑब्जेक्ट्स का एक टपल लौटाता है।
गुण
- .width – पिक्सेल में पता लगाई गई वस्तु की चौड़ाई।
- .height – पिक्सेल में पता लगाई गई वस्तु की ऊँचाई।
- .centerX – पिक्सेल में वस्तु के केंद्र की X स्थिति।
- .centerY – पिक्सेल में वस्तु के केंद्र की Y स्थिति।
- .originX – पिक्सेल में वस्तु के शीर्ष-बाएँ कोने की X स्थिति।
- .originY – पिक्सेल में वस्तु के शीर्ष-बाएँ कोने की Y स्थिति।
- .id – पता लगाए गए ऑब्जेक्ट का वर्गीकरण आईडी।

कंसोल – कंसोल पर प्रिंट करें और मानों की निगरानी करें।

प्रिंट
- brain.screen.print — कंसोल में टेक्स्ट, संख्याएँ या चर मान प्रदर्शित करता है।
- brain.screen.next_row — कंसोल कर्सर को अगली पंक्ति की शुरुआत में ले जाता है।
- brain.screen.clear_screen — कंसोल से सभी पंक्तियों को साफ़ करता है।
निगरानी करना
- monitor_variable — मॉनिटर टैब में एक या अधिक पूर्वनिर्धारित चर जोड़ता है।
- monitor_sensor — मॉनिटर टैब में एक या अधिक सेंसर मान जोड़ता है।

संवेदन – रोबोट के विभिन्न सेंसरों का उपयोग करें।

दूरी
- found_object – लौटाता है कि दूरी सेंसर सीमा के भीतर किसी वस्तु का पता लगाता है या नहीं।
- object_distance – दूरी सेंसर और निकटतम पता लगाए गए ऑब्जेक्ट के बीच की दूरी लौटाता है।
GPS
- x_position – फ़ील्ड पर जीपीएस सेंसर का वर्तमान x-निर्देशांक लौटाता है।
- y_position – फ़ील्ड पर जीपीएस सेंसर का वर्तमान y-निर्देशांक लौटाता है।
- heading – जीपीएस सेंसर के आधार पर रोबोट जिस दिशा में वर्तमान में है, उसे लौटाता है।

इस पृष्ठ पर दिए गए उदाहरणों में प्लेग्राउंड की प्री-मैच चेकलिस्ट से स्टार्टिंग लोकेशन C का उपयोग किया गया है।

ड्राइवट्रेन #

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

कार्रवाई #

गाड़ी चलाना #

drive रोबोट को निरंतर आगे या पीछे ले जाता है। रोबोट तब तक चलता रहेगा जब तक उसे कोई और क्रिया, जैसे मुड़ना या रुकना, करने का निर्देश नहीं दिया जाता।

Usage:
drivetrain.drive(direction)

पैरामीटर	विवरण
`direction`	रोबोट की गति की दिशा: `FORWARD` या `REVERSE`।

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive(FORWARD)
    wait(0.5, SECONDS)
    drivetrain.stop()
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

ड्राइव_के लिए #

drive_for कमांड रोबोट को एक निश्चित दूरी तक आगे या पीछे ले जाता है। प्रोजेक्ट रोबोट के चलने के पूरा होने तक प्रतीक्षा करेगा, उसके बाद ही कोड की अगली पंक्ति चलेगी।

Usage:
drivetrain.drive_for(direction, distance, units, wait)

पैरामीटर	विवरण
`direction`	रोबोट की गति की दिशा: `FORWARD` या `REVERSE`।
`distance`	रोबोट द्वारा तय की गई दूरी। यह `integer` या दशमलव (`float` ) हो सकता है।
`units`	वैकल्पिक। दूरी की इकाई: `INCHES` (डिफ़ॉल्ट) या `MM` (मिलीमीटर)।
`wait`	वैकल्पिक। `wait=True` (डिफ़ॉल्ट) कोड की अगली पंक्ति चलने से पहले रोबोट के चलने के पूरा होने तक प्रोजेक्ट को प्रतीक्षा कराता है। `wait=False` कोड की अगली पंक्ति तुरंत चलती है।

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

मोड़#

turn रोबोट को हमेशा के लिए बाएँ या दाएँ घुमाता है। रोबोट तब तक घूमता रहेगा जब तक उसे कोई और क्रिया, जैसे चलाना या रोकना, करने को न कहा जाए।

Usage:
drivetrain.turn(direction)

पैरामीटर	विवरण
`direction`	रोबोट के मुड़ने की दिशा: `LEFT` या `RIGHT`।

def main():
    # Score a Pin in a Neutral Goal
    drivetrain.turn(LEFT)
    wait(0.78, SECONDS)
    drivetrain.stop()
    arm_motor.spin_for(FORWARD, 800, DEGREES)
    drivetrain.drive_for(FORWARD, 25, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

मोड़ के लिए #

turn_for रोबोट को एक निश्चित डिग्री तक बाएँ या दाएँ घुमाता है। यह घुमाव रोबोट की वर्तमान स्थिति के सापेक्ष होता है। रोबोट के पूरा घूमने तक प्रोजेक्ट अगली कोड लाइन नहीं चलाएगा।

Usage:
drivetrain.turn_for(direction, angle, units, wait)

पैरामीटर	विवरण
`direction`	रोबोट के मुड़ने की दिशा: `LEFT` या `RIGHT`।
`angle`	रोबोट जितने डिग्री घूमता है, उसकी संख्या। यह `integer` या दशमलव (`float` ) हो सकता है।
`units`	वैकल्पिक। कोण की इकाई: `DEGREES` (डिफ़ॉल्ट)।
`wait`	वैकल्पिक। `wait=True` (डिफ़ॉल्ट) कोड की अगली पंक्ति चलने से पहले रोबोट के मुड़ने की प्रक्रिया पूरी होने तक प्रोजेक्ट को प्रतीक्षा कराता है। `wait=False` कोड की अगली पंक्ति तुरंत चलती है।

def main():
    # Score a Pin in a Neutral Goal
    drivetrain.turn_for(LEFT, 110, DEGREES)
    arm_motor.spin_for(FORWARD, 800, DEGREES)
    drivetrain.drive_for(FORWARD, 25, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

हेडिंग रोबोट की दिशा है, जिसे डिग्री में मापा जाता है। turn_to_heading रोबोट को -359 से 359 डिग्री के बीच किसी विशिष्ट हेडिंग की ओर मोड़ता है। रोबोट लक्ष्य हेडिंग तक पहुँचने के लिए सबसे छोटी दिशा में मुड़ेगा।

प्रारंभिक दिशा 0 डिग्री है।

Usage:
drivetrain.turn_to_heading(heading, units, wait)

पैरामीटर	विवरण
`heading`	रोबोट को -359 से 359 डिग्री के बीच की दिशा में मुड़ना चाहिए।
`units`	वैकल्पिक। कोण की इकाई: `DEGREES` (डिफ़ॉल्ट)।
`wait`	वैकल्पिक। `wait=True` (डिफ़ॉल्ट) कोड की अगली पंक्ति चलने से पहले रोबोट के मुड़ने की प्रक्रिया पूरी होने तक प्रोजेक्ट को प्रतीक्षा कराता है। `wait=False` कोड की अगली पंक्ति तुरंत चलती है।

def main():
    # Score a Pin in a Neutral Goal
    drivetrain.turn_to_heading(-110, DEGREES)
    arm_motor.spin_for(FORWARD, 800, DEGREES)
    drivetrain.drive_for(FORWARD, 25, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

घुमाव की ओर मुड़ें #

turn_to_rotation रोबोट को एक विशिष्ट रोटेशन में घुमाता है।

रोटेशन वह मात्रा है जो रोबोट ने डिग्री में मापी है। प्रोजेक्ट की शुरुआत में, रोटेशन का मान 0 डिग्री पर सेट होता है। दाईं ओर मुड़ने से रोटेशन बढ़ता है, और बाईं ओर मुड़ने से रोटेशन घटता है।

उदाहरण के लिए, यदि रोबोट 0 डिग्री से शुरू होकर 720 डिग्री घूमता है, तो वह दो बार दाईं ओर मुड़ेगा। यदि वह फिर 360 डिग्री घूमता है, तो वह एक बार बाईं ओर मुड़ेगा, क्योंकि 360, 720 से कम है।

Usage:
drivetrain.turn_to_rotation(rotation, units, wait)

पैरामीटर	विवरण
`rotation`	रोबोट जिस डिग्री में घूमेगा, उसका घूर्णन मान। यह `integer` या दशमलव (`float` ) हो सकता है।
`units`	वैकल्पिक। कोण की इकाई: `DEGREES` (डिफ़ॉल्ट)।
`wait`	वैकल्पिक। `wait=True` (डिफ़ॉल्ट) कोड की अगली पंक्ति चलने से पहले रोबोट के मुड़ने की प्रक्रिया पूरी होने तक प्रोजेक्ट को प्रतीक्षा कराता है। `wait=False` कोड की अगली पंक्ति तुरंत चलती है।

def main():
    # Score a Pin in a Neutral Goal
    drivetrain.turn_to_rotation(-110, DEGREES)
    arm_motor.spin_for(FORWARD, 800, DEGREES)
    drivetrain.drive_for(FORWARD, 25, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

रुकना #

stop रोबोट की गति को रोक देता है।

Usage:
drivetrain.stop()

पैरामीटर	विवरण
	इस विधि के कोई मानदंड नहीं हैं।

def main():
    # Score a Pin in a Neutral Goal
    drivetrain.turn(LEFT)
    wait(0.78, SECONDS)
    drivetrain.stop()
    arm_motor.spin_for(FORWARD, 800, DEGREES)
    drivetrain.drive_for(FORWARD, 25, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

उत्परिवर्तक #

शीर्षक सेट करें #

हेडिंग वह दिशा है जिस ओर रोबोट का मुख है, जिसे डिग्री में मापा जाता है। set_heading रोबोट की वर्तमान हेडिंग को एक नए हेडिंग मान में बदल देता है।

उदाहरण के लिए, यदि रोबोट दाईं ओर मुड़ गया है, तो दिशा को 0 डिग्री पर सेट करने से वह दाईं ओर की स्थिति ही नई 0 डिग्री बन जाती है। फिर रोबोट उस नई दिशा के आधार पर अन्य स्थितियों में मुड़ सकता है।

Usage:
drivetrain.set_heading(heading, units)

पैरामीटर	विवरण
`heading`	रोबोट के लिए निर्धारित की जाने वाली दिशा का मान (डिग्री में)।
`units`	वैकल्पिक। कोण की इकाई: `DEGREES` (डिफ़ॉल्ट)।

def main():
    # Make facing the Neutral Goal the new heading
    drivetrain.set_heading(110, DEGREES)
    drivetrain.turn_to_heading(0, DEGREES)

# VR threads — Do not delete
vr_thread(main)

सेट_रोटेशन #

रोटेशन वह मात्रा है जो रोबोट ने डिग्री में घुमाई है। set_rotation रोबोट के वर्तमान रोटेशन को एक नए मान में बदल देता है।

Usage:
drivetrain.set_rotation(rotation, units)

पैरामीटर	विवरण
`rotation`	रोबोट के लिए निर्धारित की जाने वाली घूर्णन मान (डिग्री में)। यह `integer` या दशमलव (`float` ) हो सकता है।
`units`	वैकल्पिक। कोण की इकाई: `DEGREES` (डिफ़ॉल्ट)।

def main():
    # Make facing the Neutral Goal the new rotation
    drivetrain.set_rotation(110, DEGREES)
    drivetrain.turn_to_rotation(0, DEGREES)

# VR threads — Do not delete
vr_thread(main)

सेट_टाइमआउट #

set_timeout निर्धारित करता है कि रोबोट किसी गतिविधि को पूरा करने के लिए कितने सेकंड तक प्रयास करेगा। यदि रोबोट उस समय में गतिविधि पूरी नहीं कर पाता है, तो वह प्रयास करना बंद कर देगा और कोड की अगली पंक्ति पर चला जाएगा। इससे रोबोट को किसी गतिविधि में अटकने से बचाया जा सकता है।

Usage:
drivetrain.set_timeout(time, units)

पैरामीटर	विवरण
`time`	रोबोट को किसी गतिविधि को पूरा करने के लिए जितने सेकंड का समय मिल सकता है। यह एक धनात्मक पूर्णांक `integer` ) या दशमलव (`float` ) हो सकता है।
`units`	वैकल्पिक। समय इकाई: `SECONDS` (डिफ़ॉल्ट) या `MSEC`।

def main():
    # Turn to face the Neutral Goal
    drivetrain.set_timeout(0.8, SECONDS)
    drivetrain.turn_for(LEFT, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

सेट_ड्राइव_वेग #

set_drive_velocity रोबोट को बताता है कि उसे कितनी गति से चलना है। उच्च प्रतिशत होने पर रोबोट तेजी से चलता है और निम्न प्रतिशत होने पर रोबोट धीरे चलता है।

प्रत्येक परियोजना की शुरुआत में रोबोट डिफ़ॉल्ट रूप से 50% वेग से चलता है।

ध्यान दें: अधिक वेग से रोबोट की गति बढ़ जाती है, लेकिन सटीकता कम हो सकती है। कम वेग से रोबोट की गति धीमी हो जाती है, लेकिन सटीकता अधिक हो सकती है।

Usage:
drivetrain.set_drive_velocity(velocity, units)

पैरामीटर	विवरण
`velocity`	0% से 100% तक की गति, जिसके साथ वाहन चलाना है। यह एक पूर्णांक `integer` या दशमलव (`float` ) हो सकता है।
`units`	वैकल्पिक। वेग इकाई: `PERCENT` (डिफ़ॉल्ट)।

def main():
    # Score a Pin in a Neutral Goal
    drivetrain.turn_for(LEFT, 110, DEGREES)
    arm_motor.spin_for(FORWARD, 800, DEGREES)
    drivetrain.set_drive_velocity(100, PERCENT)
    drivetrain.drive_for(FORWARD, 25, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

सेट_टर्न_वेलोसिटी #

set_turn_velocity रोबोट को बताता है कि उसे कितनी तेज़ी से मुड़ना है। उच्च प्रतिशत होने पर रोबोट तेज़ी से मुड़ता है और निम्न प्रतिशत होने पर रोबोट धीरे मुड़ता है।

प्रत्येक परियोजना की शुरुआत में रोबोट डिफ़ॉल्ट रूप से 50% वेग से घूमना शुरू करता है।

ध्यान दें: अधिक वेग से रोबोट तेजी से मुड़ता है, लेकिन सटीकता कम हो सकती है। कम वेग से रोबोट धीरे मुड़ता है, लेकिन सटीकता अधिक हो सकती है।

Usage:
drivetrain.set_turn_velocity(velocity, units)

पैरामीटर	विवरण
`velocity`	0% से 100% तक घूमने की गति। यह एक पूर्णांक `integer` या दशमलव (`float` ) हो सकता है।
`units`	वैकल्पिक। वेग इकाई: `PERCENT` (डिफ़ॉल्ट)।

def main():
    # Turn to face the Neutral Goal faster
    drivetrain.set_turn_velocity(100, PERCENT)
    drivetrain.turn_for(LEFT, 110, DEGREES)

# VR threads — Do not delete
vr_thread(main)

टिककर खेल #

शीर्षक #

हेडिंग रोबोट की दिशा को दर्शाती है, जिसे डिग्री में मापा जाता है। heading रोबोट की वर्तमान हेडिंग को 0 से 359.99 डिग्री के बीच दर्शाती है।

रोबोट की प्रारंभिक दिशा 0 डिग्री है।

Usage:
drivetrain.heading(units)

पैरामीटर	विवरण
`units`	वैकल्पिक। हेडिंग इकाई: `DEGREES` (डिफ़ॉल्ट)।

def main():
    # Turn to the Goal, then show heading
    drivetrain.turn_for(LEFT, 110, DEGREES)
    brain.screen.print("Heading: ")
    brain.screen.print(drivetrain.heading(DEGREES))

# VR threads — Do not delete
vr_thread(main)

ROTATION #

रोटेशन वह मात्रा है जो रोबोट ने डिग्री में घुमाई है। प्रोजेक्ट की शुरुआत में, रोटेशन का मान 0 डिग्री पर सेट होता है। rotation रोबोट का वर्तमान रोटेशन दिखाता है।

दाहिनी ओर मुड़ने से घूर्णन बढ़ता है, और बाईं ओर मुड़ने से घूर्णन घटता है। उदाहरण के लिए, दाहिनी ओर दो पूरे चक्कर लगाने से 720 डिग्री का घूर्णन प्राप्त होगा।

Usage:
drivetrain.rotation(units)

पैरामीटर	विवरण
`units`	वैकल्पिक। घूर्णन इकाई: `DEGREES` (डिफ़ॉल्ट)।

def main():
    # Spin to find a Pin, then show rotation
    drivetrain.turn_for(RIGHT, 450, DEGREES)
    brain.screen.print("Rotation: ")
    brain.screen.print(drivetrain.rotation(DEGREES))

# VR threads — Do not delete
vr_thread(main)

कर दिया है #

is_done बूलियन मान के रूप में बताता है कि रोबोट ने चलना समाप्त कर दिया है या नहीं। इसका उपयोग रोबोट की गति के आधार पर अन्य व्यवहारों के समय को नियंत्रित करने के लिए किया जा सकता है।

True — रोबोट का चलना समाप्त हो गया है।
False — रोबोट अभी भी चल रहा है।

यह विधि निम्नलिखित ड्राइवट्रेन विधियों के साथ मिलकर काम करती है जिनमें wait पैरामीटर है: drive_for, turn_for, turn_to_heading, और turn_to_rotation।

Usage:
drivetrain.is_done()

पैरामीटर	विवरण
	इस विधि के कोई मानदंड नहीं हैं।

def main():
    # Score a Pin in a Neutral Goal
    drivetrain.turn_for(LEFT, 110, DEGREES)
    arm_motor.spin_for(FORWARD, 800, DEGREES)
    drivetrain.drive_for(FORWARD, 25, INCHES, wait=False)
    wait(0.5, SECONDS)
    while not drivetrain.is_done():
        wait(5, MSEC)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

चल रहा है #

is_moving बूलियन मान के रूप में बताता है कि रोबोट चल रहा है या नहीं। इसका उपयोग रोबोट की गति के आधार पर अन्य व्यवहारों के समय को नियंत्रित करने के लिए किया जा सकता है।

True — रोबोट चल रहा है।
False — रोबोट हिल नहीं रहा है।

Usage:
drivetrain.is_moving()

पैरामीटर	विवरण
	इस विधि के कोई मानदंड नहीं हैं।

def main():
    # Raise the Arm once stopped near the Goal
    drivetrain.turn_for(LEFT, 110, DEGREES)
    drivetrain.drive_for(FORWARD, 25, INCHES, wait=False)
    wait (0.5, SEC)
    while drivetrain.is_moving():
        wait(5, MSEC)
    arm_motor.spin_for(FORWARD, 800, DEGREES)

# VR threads — Do not delete
vr_thread(main)

वेग #

velocity रोबोट की गति को -100% से 100% तक के प्रतिशत के रूप में दर्शाता है।

Usage:
drivetrain.velocity(units)

पैरामीटर	विवरण
`units`	वैकल्पिक। वेग इकाई: `PERCENT` (डिफ़ॉल्ट)।

def main():
    # Show speed while driving to the Goal
    drivetrain.drive_for(FORWARD, 150, MM)
    brain.screen.print("Velocity: ")
    brain.screen.print(drivetrain.velocity(PERCENT))

# VR threads — Do not delete
vr_thread(main)

गति #

फ्लेक्स, आर्म को ऊपर उठाने और नीचे करने के लिए आर्म मोटर का और क्लॉ को खोलने और बंद करने के लिए क्लॉ मोटर का उपयोग करता है।

प्रत्येक मोटर की अपनी दिशात्मक व्यवहार क्षमता होती है। दिशा विवरण यह बताता है कि फ्लेक्स पर प्रत्येक दिशा उस मोटर को कैसे चलाती है।

कार्रवाई #

घुमाना #

spin कमांड मोटर को दो दिशाओं में से किसी एक दिशा में लगातार घुमाता रहता है। मोटर तब तक घूमती रहेगी जब तक उसे कोई दूसरी क्रिया न दी जाए, जैसे कि उसे किसी दूसरी दिशा में घुमाना या रोकना।

उपयोग:
इस विधि के साथ उपलब्ध दो मोटर ऑब्जेक्ट में से किसी एक का उपयोग किया जा सकता है, जैसा कि नीचे दिखाया गया है:

मोटर	आज्ञा
`arm_motor`	`arm_motor.spin(direction)` — आर्म मोटर
`claw_motor`	`claw_motor.spin(direction)` — क्लॉ मोटर

पैरामीटर

विवरण

direction

मोटर के घूमने की दिशा:

FORWARD — आर्म मोटर को ऊपर ले जाता है या क्लॉ मोटर को बंद करता है।
REVERSE — आर्म मोटर को नीचे ले जाता है या क्लॉ मोटर को खोलता है।

def main():
    # Raise the Arm before driving toward a Pin
    arm_motor.spin(FORWARD)
    wait(1, SECONDS)
    arm_motor.stop()

# VR threads — Do not delete
vr_thread(main)

स्पिन_फॉर #

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

मोटर	आज्ञा
`arm_motor`	`arm_motor.spin_for(direction, distance, units, wait)` — आर्म मोटर
`claw_motor`	`claw_motor.spin_for(direction, distance, units, wait)` — क्लॉ मोटर

पैरामीटर	विवरण
`direction`	मोटर के घूमने की दिशा: `FORWARD` — आर्म मोटर को ऊपर ले जाता है या क्लॉ मोटर को बंद करता है। `REVERSE` — आर्म मोटर को नीचे ले जाता है या क्लॉ मोटर को खोलता है।
`distance`	मोटर के घूमने की दूरी। `DEGREES` (पूर्णांकों का प्रयोग करें)। `TURNS` पूर्णांकों या दशमलव संख्याओं का प्रयोग कर सकते हैं)।
`units`	वैकल्पिक। दूरी इकाई: `DEGREES` (डिफ़ॉल्ट) या `TURNS`।
`wait`	वैकल्पिक। `wait=True` (डिफ़ॉल्ट) — अगली कोड लाइन चलने से पहले प्रोजेक्ट को मोटर के घूमना बंद होने तक प्रतीक्षा कराता है। `wait=False` — अगली कोड लाइन तुरंत चलाता है।

def main():
    # Raise the Arm to carry the Pin to the Goal
    arm_motor.spin_for(FORWARD, 800, DEGREES)

# VR threads — Do not delete
vr_thread(main)

स्पिन_टू_पोजिशन #

spin_to_position कमांड spin_to_position करके मोटर को एक विशिष्ट स्थिति में घुमाया जाता है।

मोटर की स्थिति उसके घूमने की दूरी को दर्शाती है, जिसे DEGREES या TURNSमें मापा जाता है। एक चक्कर 360 डिग्री के बराबर होता है। किसी प्रोजेक्ट की शुरुआत में, आर्म मोटर की स्थिति 0 डिग्री पर सेट होती है। क्लॉ मोटर इसका अपवाद है - यह 467 डिग्री (पूरी तरह बंद) से शुरू होती है। मोटर की स्थिति को set_position विधि का उपयोग करके भी सेट किया जा सकता है।

स्थिति के मान निरपेक्ष होते हैं। इसका अर्थ है कि घूर्णन की दिशा मोटर की वर्तमान स्थिति पर निर्भर करती है।

उदाहरण के लिए, यदि मोटर 0 डिग्री से शुरू होकर 720 डिग्री तक घूमती है, तो वह दो चक्कर आगे की ओर घूमेगी। यदि फिर वह 360 डिग्री तक घूमती है, तो वह एक चक्कर पीछे की ओर घूमेगी, क्योंकि 360, 720 से कम है।

मोटर	आज्ञा
`arm_motor`	`arm_motor.spin_to_position(angle, units, wait=True)` — आर्म मोटर
`claw_motor`	`claw_motor.spin_to_position(angle, units, wait=True)` — क्लॉ मोटर

पैरामीटर	विवरण
`angle`	मोटर जिस स्थिति तक घूमेगी, उसका मान। `DEGREES` (पूर्णांकों का प्रयोग करें)। `TURNS` (पूर्णांकों या दशमलव संख्याओं का प्रयोग करें)।
`units`	वैकल्पिक। स्थिति इकाई: `DEGREES` (डिफ़ॉल्ट) या `TURNS`।
`wait`	वैकल्पिक। `wait=True` (डिफ़ॉल्ट) — अगली कोड लाइन चलने से पहले प्रोजेक्ट को मोटर के घूमना बंद होने तक प्रतीक्षा कराता है। `wait=False` — अगली कोड लाइन तुरंत चलाता है।

पैरामीटर

विवरण

angle

मोटर जिस स्थिति तक घूमेगी, उसका मान। DEGREES (पूर्णांकों का प्रयोग करें)। TURNS (पूर्णांकों या दशमलव संख्याओं का प्रयोग करें)।

units

वैकल्पिक। स्थिति इकाई: DEGREES (डिफ़ॉल्ट) या TURNS।

wait

वैकल्पिक।

wait=True (डिफ़ॉल्ट) — अगली कोड लाइन चलने से पहले प्रोजेक्ट को मोटर के घूमना बंद होने तक प्रतीक्षा कराता है।
wait=False — अगली कोड लाइन तुरंत चलाता है।

def main():
    # Raise the Arm, then release the Pin
    arm_motor.spin_to_position(800, DEGREES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

रुकना #

stop मोटर को घूमने से रोकता है।

मोटर	आज्ञा
`arm_motor`	`arm_motor.stop()` — आर्म मोटर
`claw_motor`	`claw_motor.stop()` — क्लॉ मोटर

पैरामीटर	विवरण
	इस विधि के कोई मानदंड नहीं हैं।

def main():
    # Raise the Arm partway to hold the Pin
    arm_motor.spin(FORWARD)
    wait(1, SECONDS)
    arm_motor.stop()

# VR threads — Do not delete
vr_thread(main)

उत्परिवर्तक #

सेट_स्थिति #

मोटर की स्थिति यह दर्शाती है कि वह कितनी दूर घूमी है, जिसे DEGREES या TURNSमें मापा जाता है। एक चक्कर 360 डिग्री के बराबर होता है। set_position मोटर की वर्तमान स्थिति को एक नए मान में बदल देता है।

उदाहरण के लिए, यदि कोई मोटर 180 डिग्री घूम चुकी है, तो उसकी स्थिति को 0 डिग्री पर सेट करने से वह स्थिति 180 से 0 डिग्री पर रीसेट हो जाएगी। फिर मोटर उस नए मान के आधार पर अलग-अलग स्थितियों में घूम सकती है।

मोटर	आज्ञा
`arm_motor`	`arm_motor.set_position(position, units)` — आर्म मोटर
`claw_motor`	`claw_motor.set_position(position, units)` — क्लॉ मोटर

पैरामीटर	विवरण
`position`	मोटर के लिए निर्धारित की जाने वाली स्थिति का मान। `DEGREES` के लिए पूर्णांक मान का उपयोग करें। `TURNS` के लिए पूर्णांक या दशमलव मानों का उपयोग किया जा सकता है।
`units`	वैकल्पिक। स्थिति इकाई: `DEGREES` (डिफ़ॉल्ट) या `TURNS`।

def main():
    # Reset encoder, raise Arm, place Pin
    arm_motor.set_position(0, DEGREES)
    arm_motor.spin_to_position(800, DEGREES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

सेट_वेग #

set_velocity मोटर को यह बताता है कि उसे कितनी गति से घूमना है। उच्च प्रतिशत मोटर को तेज़ घुमाता है और निम्न प्रतिशत मोटर को धीमा घुमाता है।

प्रत्येक परियोजना की शुरुआत में प्रत्येक मोटर डिफ़ॉल्ट रूप से 50% वेग से घूमती है।

ध्यान दें: अधिक वेग से मोटर की गति तेज हो जाती है, लेकिन इससे सटीकता कम हो सकती है। कम वेग से मोटर की गति धीमी हो जाती है, लेकिन इससे सटीकता बढ़ सकती है।

मोटर	आज्ञा
`arm_motor`	`arm_motor.set_velocity(velocity, units)` — आर्म मोटर
`claw_motor`	`claw_motor.set_velocity(velocity, units)` — क्लॉ मोटर

पैरामीटर	विवरण
`velocity`	घूमने की गति 0% से 100% तक हो सकती है। यह `integer` या दशमलव (`float` ) हो सकता है।
`units`	वेग इकाई: `PERCENT`.

def main():
    # Raise the Arm fast to release the Pin
    arm_motor.set_velocity(100, PERCENT)
    arm_motor.spin_for(FORWARD, 800, DEGREES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

सेट_टाइमआउट #

set_timeout निर्धारित करता है कि मोटर किसी गतिविधि को पूरा करने के लिए कितना समय लेगी। यदि मोटर उस समय में गतिविधि पूरी नहीं कर पाती है, तो वह प्रयास करना बंद कर देगी और कोड की अगली पंक्ति पर चली जाएगी। इससे मोटर को गतिविधि के दौरान अटकने से बचाया जा सकता है।

मोटर	आज्ञा
`arm_motor`	`arm_motor.set_timeout(value, units)` — आर्म मोटर
`claw_motor`	`claw_motor.set_timeout(value, units)` — क्लॉ मोटर

पैरामीटर	विवरण
`value`	मोटर किसी गतिविधि को पूरा करने के लिए कितनी देर तक प्रयास कर सकती है। यह एक धनात्मक पूर्णांक `integer` ) या दशमलव (`float` ) हो सकता है।
`units`	समय इकाई: `SECONDS` या `MSEC` (मिलीसेकंड)।

def main():
    # Score a Pin in a Neutral Goal
    drivetrain.turn_for(LEFT, 110, DEGREES)
    arm_motor.set_timeout(1, SECONDS)
    arm_motor.spin_for(FORWARD, 1800, DEGREES)
    drivetrain.drive_for(FORWARD, 25, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

टिककर खेल #

कर दिया है #

is_done बूलियन मान के रूप में यह बताता है कि मोटर चलना समाप्त हो गया है या नहीं। इसका उपयोग मोटर की गति के आधार पर अन्य कार्यों के समय को नियंत्रित करने के लिए किया जा सकता है।

True — मोटर चलना समाप्त हो गया है।
False — मोटर अभी भी चल रही है।

यह विधि निम्नलिखित मोशन विधियों के साथ मिलकर काम करती है जिनमें wait पैरामीटर है: spin_for और spin_to_position।

मोटर	आज्ञा
`arm_motor`	`arm_motor.is_done()` — आर्म मोटर
`claw_motor`	`claw_motor.is_done()` — क्लॉ मोटर

पैरामीटर	विवरण
	इस विधि के कोई मानदंड नहीं हैं।

def main():
    # Raise the Arm while driving to the Goal
    arm_motor.spin_to_position(800, DEGREES, wait=False)
    wait(0.1, SECONDS)
    while not arm_motor.is_done():
        drivetrain.drive(FORWARD)
        wait(5, MSEC)
    drivetrain.stop()

# VR threads — Do not delete
vr_thread(main)

is_spinning #

is_spinning मोटर के घूमने की स्थिति को बूलियन मान के रूप में दर्शाता है। इसका उपयोग मोटर की गति के आधार पर अन्य कार्यों के समय को नियंत्रित करने के लिए किया जा सकता है।

True — मोटर घूम रही है।
False — मोटर नहीं घूम रही है।

मोटर	आज्ञा
`arm_motor`	`arm_motor.is_spinning()` — आर्म मोटर
`claw_motor`	`claw_motor.is_spinning()` — क्लॉ मोटर

पैरामीटर	विवरण
	इस विधि के कोई मानदंड नहीं हैं।

def main():
    # Raise the Arm while driving to the Goal, then release the Pin
    arm_motor.spin_to_position(800, DEGREES, wait=False)
    wait(0.1, SECONDS)
    while arm_motor.is_spinning():
        drivetrain.drive_for(FORWARD, 25, MM)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

पद #

मोटर की स्थिति यह दर्शाती है कि वह कितनी दूर घूमी है, जिसे DEGREES या TURNSमें मापा जाता है। एक चक्कर 360 डिग्री के बराबर होता है। position मोटर की वर्तमान स्थिति बताती है।

किसी प्रोजेक्ट की शुरुआत में, आर्म मोटर की स्थिति 0 डिग्री पर सेट होती है। क्लॉ मोटर इसका अपवाद है - यह 467 डिग्री (पूरी तरह बंद) पर शुरू होती है। यदि मोटर एक पूरा चक्कर आगे की ओर घूमती है, तो स्थिति बढ़ जाती है। यदि मोटर दूसरी दिशा में घूमती है, तो स्थिति घट जाती है।

मोटर	आज्ञा
`arm_motor`	`arm_motor.position(units)` — आर्म मोटर
`claw_motor`	`claw_motor.position(units)` — क्लॉ मोटर

पैरामीटर	विवरण
`units`	मोटर की स्थिति को वापस लाने के लिए इकाई: `DEGREES` या `TURNS`.

def main():
    # Raise the Arm, then release the Pin
    while arm_motor.position(DEGREES) < 800:
        arm_motor.spin(FORWARD)
        wait(2, MSEC)
    arm_motor.stop()
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

वेग #

velocity यह बताता है कि मोटर कितनी तेजी से घूम रही है।

धनात्मक मान का अर्थ है कि मोटर आगे की ओर घूम रही है। ऋणात्मक मान का अर्थ है कि मोटर विपरीत दिशा में घूम रही है।

मोटर	आज्ञा
`arm_motor`	`arm_motor.velocity(units)` — आर्म मोटर
`claw_motor`	`claw_motor.velocity(units)` — क्लॉ मोटर

पैरामीटर	विवरण
`units`	वापसी के लिए वेग इकाई: `PERCENT`.

def main():
    # Show Arm Motor velocity while raising
    arm_motor.set_velocity(100, PERCENT)
    arm_motor.spin_to_position(800, DEGREES, wait=False)
    wait(0.2, SECONDS)
    brain.screen.print(arm_motor.velocity(PERCENT))

# VR threads — Do not delete
vr_thread(main)

एआई विज़न #

टिककर खेल #

आशुचित्र लें #

take_snapshot एआई विज़न सेंसर फ्रेम से डेटा को एक एकल हस्ताक्षर में फ़िल्टर करता है - सेंसर द्वारा पहचाने जा सकने वाली किसी चीज़ का सहेजा गया विवरण, जैसे कि मैदान पर एक खेल तत्व - और एक टपल लौटाता है।

यह टपल, इंडेक्स 0 से शुरू होकर, चौड़ाई के अनुसार सबसे बड़े से सबसे छोटे क्रम में व्यवस्थित वस्तुओं को संग्रहीत करता है। प्रत्येक वस्तु के गुण को उसके इंडेक्स का उपयोग करके एक्सेस किया जा सकता है। यदि कोई मेल खाने वाली वस्तुएँ नहीं मिलती हैं, तो एक खाली टपल लौटाया जाता है।

Usage:
ai_vision.take_snapshot(signature)

पैरामीटर	विवरण
`signature`	दिए गए सिग्नेचर के डेटा को ही शामिल करने के लिए डेटासेट को फ़िल्टर करता है। उपलब्ध सिग्नेचर हैं: `AiVision.ALL_AIOBJS` - सभी गेम तत्वों का पता लगाता है। `GameElements.RED_BLUE_PIN` - RedBluePin गेम तत्वों का पता लगाता है। `GameElements.BLUE_YELLOW_PIN` - BlueYellowPin गेम तत्वों का पता लगाता है। `GameElements.RED_YELLOW_PIN` - RedYellowPin गेम तत्वों का पता लगाता है। `GameElements.YELLOW_PIN` - YellowPin गेम तत्वों का पता लगाता है। `GameElements.CUP` - Cup गेम तत्वों का पता लगाता है।

पैरामीटर

विवरण

signature

दिए गए सिग्नेचर के डेटा को ही शामिल करने के लिए डेटासेट को फ़िल्टर करता है। उपलब्ध सिग्नेचर हैं:

AiVision.ALL_AIOBJS - सभी गेम तत्वों का पता लगाता है।
GameElements.RED_BLUE_PIN - RedBluePin गेम तत्वों का पता लगाता है।
GameElements.BLUE_YELLOW_PIN - BlueYellowPin गेम तत्वों का पता लगाता है।
GameElements.RED_YELLOW_PIN - RedYellowPin गेम तत्वों का पता लगाता है।
GameElements.YELLOW_PIN - YellowPin गेम तत्वों का पता लगाता है।
GameElements.CUP - Cup गेम तत्वों का पता लगाता है।

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

    drivetrain.turn_for(LEFT, 70, DEGREES)

    # Turn to face the Pin
    drivetrain.set_turn_velocity(30, PERCENT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].centerX < 140:
                drivetrain.turn(LEFT)
            elif ai_objects[0].centerX > 180:
                drivetrain.turn(RIGHT)
            else:
                drivetrain.stop()
                break

# VR threads — Do not delete
vr_thread(main)

गुण #

टपल में संग्रहीत प्रत्येक ऑब्जेक्ट के साथ सात गुण शामिल होते हैं take_snapshot का उपयोग किया जाता है।

.id को छोड़कर सभी प्रॉपर्टी मान, AI विज़न सेंसर के दृश्य में पता लगाए गए ऑब्जेक्ट की स्थिति और आकार का वर्णन करते हैं, जिस क्षण take_snapshot का उपयोग किया गया था। ये मान सेंसर के 320 x 240 पिक्सेल रिज़ॉल्यूशन के आधार पर पिक्सेल में मापे जाते हैं।

।चौड़ाई #

.width पिक्सेल में पता लगाए गए ऑब्जेक्ट की चौड़ाई लौटाता है, जो 1 और 320 के बीच एक पूर्णांक है।

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

    drivetrain.turn_for(LEFT, 70, DEGREES)

    # Approach the next Cup and Pin
    drivetrain.set_drive_velocity(30, PERCENT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].width > 140:
                drivetrain.stop()
                break
            else:
                drivetrain.drive(FORWARD)

# VR threads — Do not delete
vr_thread(main)

।ऊंचाई #

.height पिक्सेल में पता लगाए गए ऑब्जेक्ट की ऊंचाई लौटाता है, जो 1 और 240 के बीच एक पूर्णांक है।

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

    drivetrain.turn_for(LEFT, 70, DEGREES)

    # Approach the next Cup and Pin
    drivetrain.set_drive_velocity(30, PERCENT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].height > 200:
                drivetrain.stop()
                break
            else:
                drivetrain.drive(FORWARD)

# VR threads — Do not delete
vr_thread(main)

.केंद्रएक्स #

.centerX पता लगाए गए ऑब्जेक्ट के केंद्र का x-निर्देशांक पिक्सेल में लौटाता है, जो 0 और 320 के बीच एक पूर्णांक है।

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

    drivetrain.turn_for(LEFT, 70, DEGREES)

    # Turn and approach the next Cup and Pin
    drivetrain.set_turn_velocity(30, PERCENT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].centerX < 140:
                drivetrain.turn_for(LEFT, 5, DEGREES)
            else: 
                drivetrain.drive_for(FORWARD, 25, INCHES)
                break

# VR threads — Do not delete
vr_thread(main)

.केंद्रवाई #

.centerY पता लगाए गए ऑब्जेक्ट के केंद्र का y-निर्देशांक पिक्सेल में लौटाता है, जो 0 और 240 के बीच एक पूर्णांक है।

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

    drivetrain.turn_for(LEFT, 70, DEGREES)

    # Approach the next Cup and Pin
    drivetrain.set_drive_velocity(30, PERCENT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].centerY > 230:
                drivetrain.stop()
                break
            else:
                drivetrain.drive(FORWARD)

# VR threads — Do not delete
vr_thread(main)

.originX #

.originX पता लगाए गए ऑब्जेक्ट के बाउंडिंग बॉक्स के ऊपरी-बाएँ कोने का x-निर्देशांक पिक्सेल में लौटाता है, जो 0 और 320 के बीच एक पूर्णांक है।

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

    drivetrain.turn_for(LEFT, 70, DEGREES)

    # Turn and approach the next Cup and Pin
    drivetrain.set_turn_velocity(30, PERCENT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].originX < 100:
                drivetrain.turn_for(LEFT, 5, DEGREES)
            else:
                drivetrain.drive_for(FORWARD, 25, INCHES)
                break

# VR threads — Do not delete
vr_thread(main)

.originY #

.originY पता लगाए गए ऑब्जेक्ट के बाउंडिंग बॉक्स के ऊपरी-बाएँ कोने का y-निर्देशांक पिक्सेल में लौटाता है, जो 0 और 240 के बीच एक पूर्णांक है।

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

    drivetrain.turn_for(LEFT, 70, DEGREES)

    # Approach the next Cup and Pin
    drivetrain.set_drive_velocity(30, PERCENT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].originY > 140:
                drivetrain.stop()
                break
            else:
                drivetrain.drive(FORWARD)

# VR threads — Do not delete
vr_thread(main)

।पहचान #

.id पता लगाए गए एआई वर्गीकरण की आईडी को पूर्णांक के रूप में लौटाता है।

एआई वर्गीकरण	पहचान	हस्ताक्षर
रेडब्लू पिन	0	`GameElements.RED_BLUE_PIN`
ब्लूयेलोपिन	1	`GameElements.BLUE_YELLOW_PIN`
रेडयेलोपिन	2	`GameElements.RED_YELLOW_PIN`
येलोपिन	3	`GameElements.YELLOW_PIN`
कप	4	`GameElements.CUP`

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

    drivetrain.turn_for(LEFT, 70, DEGREES)

    # Display the ID of the next closest object
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            brain.screen.print(ai_objects[0].id)
            break

# VR threads — Do not delete
vr_thread(main)

सांत्वना देना #

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

छाप #

ब्रेन.स्क्रीन.प्रिंट #

brain.screen.print वर्तमान कर्सर स्थिति का उपयोग करके कंसोल में टेक्स्ट, संख्याएँ या चर मान प्रदर्शित करता है।

जब आप चाहते हैं कि अगला मुद्रित मान एक नई पंक्ति से शुरू हो, तो brain.screen.next_row का उपयोग करें।

Usage:
brain.screen.print(value)

पैरामीटर	विवरण
`value`	कंसोल में प्रदर्शित करने के लिए टेक्स्ट, संख्या या वेरिएबल का मान।

def main():
    # Display a message in the Console
    brain.screen.print("Hello, robot!")

# VR threads — Do not delete
vr_thread(main)

ब्रेन.स्क्रीन.नेक्स्ट_रो #

brain.screen.next_row कर्सर को कंसोल में अगली पंक्ति के कॉलम 1 पर ले जाता है। प्रिंट होने वाला अगला मान उसी पंक्ति में दिखाई देगा।

Usage:
brain.screen.next_row()

पैरामीटर	विवरण
	इस विधि के कोई मानदंड नहीं हैं।

def main():
    # Print on two rows
    brain.screen.print("Row 1")
    brain.screen.next_row()
    brain.screen.print("Row 2")

# VR threads — Do not delete
vr_thread(main)

ब्रेन.स्क्रीन.क्लियर_स्क्रीन #

brain.screen.clear_screen कंसोल से सभी पंक्तियों को साफ़ करता है और कर्सर को वापस पंक्ति 1 पर ले जाता है।

Usage:
brain.screen.clear_screen()

पैरामीटर	विवरण
	इस विधि के कोई मानदंड नहीं हैं।

def main():
    # Display text, then clear it after two seconds
    brain.screen.print("This will disappear...")
    wait(2, SECONDS)
    brain.screen.clear_screen()

# VR threads — Do not delete
vr_thread(main)

निगरानी करना #

मॉनिटर_चर #

monitor_variable VEXcode के मॉनिटर टैब में एक या अधिक पूर्वनिर्धारित चर जोड़ता है। इससे आप प्रोजेक्ट के चलने के दौरान किसी चर के मान में होने वाले परिवर्तन को देख सकते हैं।

वेरिएबल्स को सफलतापूर्वक मॉनिटर करने के लिए monitor_variable प्रत्येक वेरिएबल का नाम स्ट्रिंग के रूप में प्रदान करें।

Usage:
monitor_variable(“variable”)
monitor_variable(“variable1”, “variable2”)

पैरामीटर	विवरण
`variable`	मॉनिटर किए जाने वाले पूर्वनिर्धारित वैश्विक चर का नाम, स्ट्रिंग के रूप में दिया गया है। एक से अधिक चरों को मॉनिटर करने के लिए, प्रत्येक चर के नाम को अल्पविराम से अलग करें।

पैरामीटर

विवरण

variable

मॉनिटर किए जाने वाले पूर्वनिर्धारित वैश्विक चर का नाम, स्ट्रिंग के रूप में दिया गया है। एक से अधिक चरों को मॉनिटर करने के लिए, प्रत्येक चर के नाम को अल्पविराम से अलग करें।

def main():
    # Monitor the number of loops
    global loops
    monitor_variable("loops")

    # Turn in a full circle 3 times
    for loops in range(12):
        drivetrain.turn_for(RIGHT, 90, DEGREES)

# VR threads — Do not delete
vr_thread(main)

मॉनिटर_सेंसर #

monitor_sensor VEXcode के मॉनिटर टैब में एक या अधिक सेंसर मान जोड़ता है। इससे आप प्रोजेक्ट के चलने के दौरान सेंसर मानों में होने वाले परिवर्तनों को देख सकते हैं।

प्रत्येक सेंसर का मान एक स्ट्रिंग के रूप में प्रदान करें।

Usage:
monitor_sensor(“sensor”)
monitor_sensor(“sensor1”, “sensor2”)

पैरामीटर	विवरण
`sensor`	मॉनिटर किए जाने वाले सेंसर का मान एक स्ट्रिंग के रूप में दिया गया है। एक से अधिक सेंसर मानों को मॉनिटर करने के लिए, प्रत्येक सेंसर मान को अल्पविराम से अलग करें। समर्थित सेंसर पहचानकर्ताओं में शामिल हैं: ब्रेन `brain.timer.time` ड्राइवट्रेन `drivetrain.is_done` `drivetrain.is_moving` `drivetrain.heading` `drivetrain.rotation` `drivetrain.velocity` आर्म मोटर `arm_motor.is_done` `arm_motor.is_spinning` `arm_motor.position` `arm_motor.velocity` क्लॉ मोटर `claw_motor.is_done` `claw_motor.is_spinning` `claw_motor.position` `claw_motor.velocity` दूरी सेंसर `distance.is_object_detected` `distance.object_distance_mm` `distance.object_distance_inches` जीपीएस सेंसर `gps.position_mm` `gps.position_inches` `gps.heading` एआई विजन सेंसर `ai_vision.object_count` `ai_vision.height` `ai_vision.width` `ai_vision.centerX` `ai_vision.centerY` `ai_vision.originX` `ai_vision.originY` `ai_vision.id`

पैरामीटर

विवरण

sensor

मॉनिटर किए जाने वाले सेंसर का मान एक स्ट्रिंग के रूप में दिया गया है। एक से अधिक सेंसर मानों को मॉनिटर करने के लिए, प्रत्येक सेंसर मान को अल्पविराम से अलग करें। समर्थित सेंसर पहचानकर्ताओं में शामिल हैं:

ब्रेन
- brain.timer.time
ड्राइवट्रेन
- drivetrain.is_done
- drivetrain.is_moving
- drivetrain.heading
- drivetrain.rotation
- drivetrain.velocity
आर्म मोटर
- arm_motor.is_done
- arm_motor.is_spinning
- arm_motor.position
- arm_motor.velocity
क्लॉ मोटर
- claw_motor.is_done
- claw_motor.is_spinning
- claw_motor.position
- claw_motor.velocity
दूरी सेंसर
- distance.is_object_detected
- distance.object_distance_mm
- distance.object_distance_inches
जीपीएस सेंसर
- gps.position_mm
- gps.position_inches
- gps.heading
एआई विजन सेंसर
- ai_vision.object_count
- ai_vision.height
- ai_vision.width
- ai_vision.centerX
- ai_vision.centerY
- ai_vision.originX
- ai_vision.originY
- ai_vision.id

def main():
    # Monitor the robot's heading
    monitor_sensor("drivetrain.heading")
    drivetrain.turn_for(RIGHT, 450, DEGREES)

# VR threads — Do not delete
vr_thread(main)

संवेदन #

दूरी #

मिली वस्तु #

found_object यह बताता है कि क्या डिस्टेंस सेंसर वर्तमान में 2000 मिमी के भीतर किसी वस्तु का पता लगाता है।

True — दूरी सेंसर किसी वस्तु का पता लगाता है।
False — दूरी सेंसर किसी वस्तु का पता नहीं लगाता है।

Usage:
distance.found_object()

पैरामीटर	विवरण
	इस विधि के कोई मानदंड नहीं हैं।

def main():
    # Turn until something is detected, then release the Pin
    drivetrain.turn(RIGHT)
    while True:
        wait(5, MSEC)
        if distance.found_object():
            drivetrain.stop()
            break
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

वस्तु_दूरी #

object_distance दूरी सेंसर और निकटतम पता लगाए गए ऑब्जेक्ट के बीच की दूरी लौटाता है।

Usage:
distance.object_distance(units)

पैरामीटर	विवरण
`units`	दूरी की इकाई: `MM` या `INCHES`.

def main():
    # Drive until 200 mm from the Goal, then release the Pin
    while distance.object_distance(MM) > 200:
        wait(5, MSEC)
        drivetrain.drive(FORWARD)
    drivetrain.stop()
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

GPS #

x_स्थिति #

x_position मैदान पर स्थित जीपीएस (गेम पोजिशनिंग सिस्टम™) सेंसर का वर्तमान x-निर्देशांक लौटाता है।

Usage:
gps.x_position(units)

पैरामीटर	विवरण
इकाइयां	ऑफसेट मान की इकाई: `INCHES` या `MM`

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive(FORWARD)
    while not gps.x_position(MM) > -1370:
        wait(2, MSEC)
    drivetrain.stop()
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

y_position #

y_position मैदान पर स्थित जीपीएस (गेम पोजिशनिंग सिस्टम™) सेंसर का वर्तमान y-निर्देशांक लौटाता है।

Usage:
gps.y_position(units)

पैरामीटर	विवरण
इकाइयां	ऑफसेट मान की इकाई: `INCHES` या `MM`

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive(FORWARD)
    while not gps.y_position(MM) < -450:
        wait(2, MSEC)
    drivetrain.stop()
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

शीर्षक #

heading जीपीएस (गेम पोजिशनिंग सिस्टम™) सेंसर की 0 से 359 डिग्री तक की रीडिंग के आधार पर रोबोट की वर्तमान दिशा को दर्शाता है।

Usage:
gps.heading()

पैरामीटर	विवरण
	इस विधि के कोई मानदंड नहीं हैं।

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    monitor_sensor("gps.heading")
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

    # Turn left to face the Neutral Goal
    drivetrain.set_turn_velocity(30, PERCENT)
    drivetrain.turn(LEFT)
    while not gps.heading() < 18:
        wait(2, MSEC)
    drivetrain.stop()


# VR threads — Do not delete
vr_thread(main)