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

परिचय

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

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

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

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

• कार्यवाही

  • स्पिन – मोटर को एक दिशा में हमेशा के लिए घुमाता है।

  • स्पिन_फॉर – मोटर को एक विशिष्ट संख्या में डिग्री या घुमावों के लिए घुमाता है।

  • स्पिन_टू_पोजिशन – मोटर को एक विशिष्ट स्थिति में घुमाता है।

  • रोकें – मोटर को घूमने से रोकता है।

• सेटिंग्स

  • set_velocity – यह निर्धारित करता है कि मोटर कितनी तेज़ी से घूमेगी।

  • set_timeout – यह निर्धारित करता है कि मोटर किसी गति को पूरा करने के लिए कितनी देर तक प्रयास करेगी।

  • set_position – मोटर की वर्तमान स्थिति को एक नए मान में बदलता है।

• मूल्य

  • is_done – यह बताता है कि मोटर चलना समाप्त हो गया है या नहीं।

  • is_spinning – यह बताता है कि मोटर घूम रही है या नहीं।

  • स्थिति – मोटर की वर्तमान स्थिति लौटाता है।

  • वेग – मोटर कितनी तेज़ी से घूम रही है, यह बताता है।

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

• गेटर्स

  • take_snapshot – सेंसर के वर्तमान फ्रेम को एक विशिष्ट हस्ताक्षर में फ़िल्टर करता है और पता लगाए गए ऑब्जेक्ट्स का एक टपल लौटाता है।

• गुण

  • .width – पिक्सेल में पता लगाए गए ऑब्जेक्ट की चौड़ाई लौटाता है।

  • .ऊंचाई – पिक्सेल में पता लगाए गए ऑब्जेक्ट की ऊंचाई लौटाता है।

  • .centerX – पता लगाए गए ऑब्जेक्ट के केंद्र का x-निर्देशांक लौटाता है।

  • .centerY – पता लगाए गए ऑब्जेक्ट के केंद्र का y-निर्देशांक लौटाता है।

  • .originX – पता लगाए गए ऑब्जेक्ट के बाउंडिंग बॉक्स के ऊपरी-बाएँ कोने का x-निर्देशांक लौटाता है।

  • .originY – पता लगाए गए ऑब्जेक्ट के बाउंडिंग बॉक्स के ऊपरी-बाएँ कोने का y-निर्देशांक लौटाता है।

  • .id – पता लगाए गए AI वर्गीकरण की ID लौटाता है।

इस पृष्ठ पर दिए गए उदाहरण डिफ़ॉल्ट प्लेग्राउंड प्रारंभ स्थिति का उपयोग करते हैं।

गति

फ्लॉप में दो रोबोट-विशिष्ट मोटर हैं: intake_motor और arm_motorदोनों मानक मोटर कमांड का उपयोग करते हैं।

दिशा स्थिरांक:

• intake_motor: FORWARD = इनटेक (इकट्ठा करता है); REVERSE = आउटटेक (बाहर निकालता है)

• arm_motor: FORWARD = ऊपर (उठाता है); REVERSE = नीचे (नीचे करता है)

घुमाना

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

Usage:
motor.spin(direction)

पैरामीटर	विवरण
direction	घुमाने की दिशा: FORWARD या REVERSE।

def main():
    # Score a Bean Bag in a Blue Goal
    drivetrain.turn_for(LEFT, 90, DEGREES)
    drivetrain.drive_for(FORWARD, 35, INCHES)
    drivetrain.turn_for(RIGHT, 90, DEGREES)
    arm_motor.spin_for(FORWARD, 1, TURNS)
    drivetrain.drive_for(FORWARD, 40, INCHES)
    intake_motor.spin(REVERSE)

# VR threads — Do not delete
vr_thread(main)

स्पिन_फॉर

spin_for एक मोटर को एक निश्चित दूरी तक घुमाता है। प्रोजेक्ट तब तक मोटर के पूरा होने का इंतजार करता है जब तक कि wait=False पास न किया जाए।

Usage:
motor.spin_for(direction, amount, unit)

पैरामीटर	विवरण
direction	घुमाने की दिशा: FORWARD या REVERSE।
amount	घुमाने की दूरी। यह एक पूर्णांक या दशमलव संख्या हो सकती है।
unit	माप की इकाई: DEGREES या TURNS.

def main():
    # Score a Bean Bag in a Blue Goal
    drivetrain.turn_for(LEFT, 90, DEGREES)
    drivetrain.drive_for(FORWARD, 35, INCHES)
    drivetrain.turn_for(RIGHT, 90, DEGREES)
    arm_motor.spin_for(FORWARD, 1, TURNS)
    drivetrain.drive_for(FORWARD, 40, INCHES)
    intake_motor.spin(REVERSE)

# VR threads — Do not delete
vr_thread(main)

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

spin_to_position मोटर को एक विशिष्ट स्थिति में घुमाता है। प्रोजेक्ट तब तक मोटर के पूरा घूमने का इंतजार करता है जब तक कि wait=False पास न किया जाए।

Usage:
motor.spin_to_position(position, unit)

पैरामीटर	विवरण
position	घूमने की स्थिति। यह एक पूर्णांक या दशमलव संख्या हो सकती है।
unit	माप की इकाई: DEGREES या TURNS.

def main():
    # Score a Bean Bag in a Blue Goal
    drivetrain.turn_for(LEFT, 90, DEGREES)
    drivetrain.drive_for(FORWARD, 35, INCHES)
    drivetrain.turn_for(RIGHT, 90, DEGREES)
    arm_motor.spin_to_position(1, TURNS)
    drivetrain.drive_for(FORWARD, 40, INCHES)
    intake_motor.spin(REVERSE)

# VR threads — Do not delete
vr_thread(main)

रुकना

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

Usage:
motor.stop()

def main():
    # Score a Bean Bag in a Blue Goal
    drivetrain.turn_for(LEFT, 90, DEGREES)
    drivetrain.drive_for(FORWARD, 35, INCHES)
    drivetrain.turn_for(RIGHT, 90, DEGREES)
    arm_motor.spin_for(FORWARD, 1, TURNS)
    drivetrain.drive_for(FORWARD, 40, INCHES)
    intake_motor.spin(REVERSE)
    wait(1, SECONDS)
    intake_motor.stop()

# VR threads — Do not delete
vr_thread(main)

सेट_वेग

set_velocity मोटर की घूमने की गति को 0 से 100 के प्रतिशत के रूप में निर्धारित करता है।

Usage:
motor.set_velocity(velocity, unit)

पैरामीटर	विवरण
velocity	मोटर का वेग प्रतिशत के रूप में, 0 से 100 के बीच।
unit	माप की इकाई: PERCENT.

def main():
    # Score a Bean Bag in a Blue Goal
    drivetrain.turn_for(LEFT, 90, DEGREES)
    drivetrain.drive_for(FORWARD, 35, INCHES)
    drivetrain.turn_for(RIGHT, 90, DEGREES)
    arm_motor.spin_for(FORWARD, 1, TURNS)
    drivetrain.drive_for(FORWARD, 40, INCHES)
    intake_motor.set_velocity(100, PERCENT)
    intake_motor.spin(REVERSE)

# VR threads — Do not delete
vr_thread(main)

सेट_टाइमआउट

set_timeout यह निर्धारित करता है कि मोटर रुकने से पहले किसी गतिविधि को पूरा करने के लिए कितने सेकंड तक प्रयास करेगी।

Usage:
motor.set_timeout(timeout, unit)

पैरामीटर	विवरण
timeout	मोटर द्वारा किसी गतिविधि को पूरा करने के लिए लिया जाने वाला समय सेकंडों में निर्धारित किया जाएगा।
unit	माप की इकाई: SECONDS.

def main():
    # Score a Bean Bag in a Blue Goal
    drivetrain.turn_for(LEFT, 90, DEGREES)
    drivetrain.drive_for(FORWARD, 35, INCHES)
    drivetrain.turn_for(RIGHT, 90, DEGREES)
    arm_motor.set_timeout(2, SECONDS)
    arm_motor.spin_for(FORWARD, 1, TURNS)
    drivetrain.drive_for(FORWARD, 40, INCHES)
    intake_motor.spin(REVERSE)

# VR threads — Do not delete
vr_thread(main)

सेट_स्थिति

set_position मोटर की वर्तमान स्थिति को एक नए मान में बदल देता है, जिससे उसका एनकोडर रीसेट हो जाता है।

Usage:
motor.set_position(position, unit)

पैरामीटर	विवरण
position	नई स्थिति का मूल्य।
unit	माप की इकाई: DEGREES या TURNS.

def main():
    # Score a Bean Bag in a Blue Goal
    drivetrain.turn_for(LEFT, 90, DEGREES)
    drivetrain.drive_for(FORWARD, 35, INCHES)
    drivetrain.turn_for(RIGHT, 90, DEGREES)
    arm_motor.set_position(0, DEGREES)
    arm_motor.spin_for(FORWARD, 1, TURNS)
    drivetrain.drive_for(FORWARD, 40, INCHES)
    intake_motor.spin(REVERSE)

# VR threads — Do not delete
vr_thread(main)

कर दिया है

is_done एक बूलियन मान लौटाता है जो यह दर्शाता है कि मोटर ने अपनी गति पूरी कर ली है या नहीं।

• True – मोटर चलना बंद कर चुकी है।

• False – मोटर अभी भी चल रही है।

Usage:
motor.is_done()

def main():
    # Score a Bean Bag in a Blue Goal
    drivetrain.turn_for(LEFT, 90, DEGREES)
    drivetrain.drive_for(FORWARD, 35, INCHES)
    drivetrain.turn_for(RIGHT, 90, DEGREES)
    arm_motor.spin_for(FORWARD, 1, TURNS, wait=False)
    while not arm_motor.is_done():
        wait(5, MSEC)
    drivetrain.drive_for(FORWARD, 40, INCHES)
    intake_motor.spin(REVERSE)

# VR threads — Do not delete
vr_thread(main)

is_spinning

is_spinning एक बूलियन मान लौटाता है जो यह दर्शाता है कि मोटर वर्तमान में घूम रही है या नहीं।

• True – मोटर घूम रही है।

• False – मोटर नहीं घूम रही है।

Usage:
motor.is_spinning()

def main():
    # Score a Bean Bag in a Blue Goal
    drivetrain.turn_for(LEFT, 90, DEGREES)
    drivetrain.drive_for(FORWARD, 35, INCHES)
    drivetrain.turn_for(RIGHT, 90, DEGREES)
    arm_motor.spin_for(FORWARD, 1, TURNS)
    drivetrain.drive_for(FORWARD, 40, INCHES)
    intake_motor.spin(REVERSE)
    while intake_motor.is_spinning():
        wait(5, MSEC)
    intake_motor.stop()

# VR threads — Do not delete
vr_thread(main)

पद

position मोटर की वर्तमान स्थिति को दर्शाता है।

Usage:
motor.position(unit)

पैरामीटर	विवरण
unit	माप की इकाई: DEGREES या TURNS.

def main():
    # Score a Bean Bag in a Blue Goal
    drivetrain.turn_for(LEFT, 90, DEGREES)
    drivetrain.drive_for(FORWARD, 35, INCHES)
    drivetrain.turn_for(RIGHT, 90, DEGREES)
    while arm_motor.position(DEGREES) < 360:
        arm_motor.spin(FORWARD)
        wait(2, MSEC)
    arm_motor.stop()
    drivetrain.drive_for(FORWARD, 40, INCHES)
    intake_motor.spin(REVERSE)

# VR threads — Do not delete
vr_thread(main)

वेग

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

Usage:
motor.velocity(unit)

पैरामीटर	विवरण
unit	माप की इकाई: PERCENT.

def main():
    # Score a Bean Bag in a Blue Goal
    drivetrain.turn_for(LEFT, 90, DEGREES)
    drivetrain.drive_for(FORWARD, 35, INCHES)
    drivetrain.turn_for(RIGHT, 90, DEGREES)
    arm_motor.spin_for(FORWARD, 1, TURNS)
    drivetrain.drive_for(FORWARD, 40, INCHES)
    intake_motor.spin(REVERSE)
    wait(0.2, SECONDS)
    brain.screen.print(intake_motor.velocity(PERCENT))

# VR threads — Do not delete
vr_thread(main)

एआई विज़न

आशुचित्र लें

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

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

Usage:
ai_vision.take_snapshot(signature)

पैरामीटर	विवरण
signature	दिए गए सिग्नेचर के डेटा को ही शामिल करने के लिए डेटासेट को फ़िल्टर करता है। उपलब्ध सिग्नेचर हैं: AiVision.ALL_AIOBJS - सभी बीन बैग का पता लगाता है। AiVision.ALL_TAGS - अप्रैल टैग का पता लगाता है, जो गोल के किनारों पर पाए जाते हैं।

def main():
    # Drop the preloaded Bean Bag
    intake_motor.spin_for(REVERSE, 180, DEGREES)
    drivetrain.turn_for(LEFT, 90, DEGREES)

    # Turn to face a red Bean Bag
    drivetrain.set_turn_velocity(30, PERCENT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        for ai_object in ai_objects:
            if ai_object.id == GameElements.RED_BEANBAG:
                if ai_object.centerX < 140:
                    drivetrain.turn(LEFT)
                elif ai_object.centerX > 180:
                    drivetrain.turn(RIGHT)
                else:
                    drivetrain.stop()
                    return
                break

# VR threads — Do not delete
vr_thread(main)

गुण

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

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

।चौड़ाई

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

def main():
    # Drop the preloaded Bean Bag
    intake_motor.spin_for(REVERSE, 180, DEGREES)
    drivetrain.turn_for(LEFT, 90, DEGREES)

    # Approach the Bean Bag, then pick it up
    drivetrain.set_drive_velocity(30, PERCENT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        for ai_object in ai_objects:
            if ai_object.id == GameElements.RED_BEANBAG:
                if ai_object.width > 200:
                    drivetrain.stop()
                    intake_motor.spin(FORWARD)
                    return
                else:
                    drivetrain.drive(FORWARD)
                break

# VR threads — Do not delete
vr_thread(main)

।ऊंचाई

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

def main():
    # Drop the preloaded Bean Bag
    intake_motor.spin_for(REVERSE, 180, DEGREES)
    drivetrain.turn_for(LEFT, 90, DEGREES)

    # Approach the Bean Bag, then pick it up
    drivetrain.set_drive_velocity(30, PERCENT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        for ai_object in ai_objects:
            if ai_object.id == GameElements.RED_BEANBAG:
                if ai_object.height > 110:
                    drivetrain.stop()
                    intake_motor.spin(FORWARD)
                    return
                else:
                    drivetrain.drive(FORWARD)
                break

# VR threads — Do not delete
vr_thread(main)

.केंद्रएक्स

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

def main():
    # Drop the preloaded Bean Bag
    intake_motor.spin_for(REVERSE, 180, DEGREES)
    drivetrain.turn_for(LEFT, 90, DEGREES)

    # Steer to keep the Bean Bag centered
    drivetrain.set_turn_velocity(30, PERCENT)
    drivetrain.set_drive_velocity(30, PERCENT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        for ai_object in ai_objects:
            if ai_object.id == GameElements.RED_BEANBAG:
                if ai_object.centerX < 140:
                    drivetrain.turn_for(LEFT, 5, DEGREES)
                else:
                    drivetrain.drive_for(FORWARD, 150, MM)
                    intake_motor.spin(FORWARD)
                    return
                break

# VR threads — Do not delete
vr_thread(main)

.केंद्रवाई

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

def main():
    # Drop the preloaded Bean Bag
    intake_motor.spin_for(REVERSE, 180, DEGREES)
    drivetrain.turn_for(LEFT, 90, DEGREES)

    # Print the y-position of the Bean Bag
    ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
    for ai_object in ai_objects:
        if ai_object.id == GameElements.RED_BEANBAG:
            brain.screen.print(ai_object.centerY)
            break

# VR threads — Do not delete
vr_thread(main)

.originX

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

def main():
    # Drop the preloaded Bean Bag
    intake_motor.spin_for(REVERSE, 180, DEGREES)
    drivetrain.turn_for(LEFT, 90, DEGREES)

    # Steer to keep the left edge centered
    drivetrain.set_turn_velocity(30, PERCENT)
    drivetrain.set_drive_velocity(30, PERCENT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        for ai_object in ai_objects:
            if ai_object.id == GameElements.RED_BEANBAG:
                if ai_object.originX < 100:
                    drivetrain.turn_for(LEFT, 5, DEGREES)
                else:
                    drivetrain.drive_for(FORWARD, 150, MM)
                    intake_motor.spin(FORWARD)
                    return
                break

# VR threads — Do not delete
vr_thread(main)

.originY

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

def main():
    # Drop the preloaded Bean Bag
    intake_motor.spin_for(REVERSE, 180, DEGREES)
    drivetrain.turn_for(LEFT, 90, DEGREES)

    # Print the y-position of the Bean Bag's top edge
    ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
    for ai_object in ai_objects:
        if ai_object.id == GameElements.RED_BEANBAG:
            brain.screen.print(ai_object.originY)
            break

# VR threads — Do not delete
vr_thread(main)

।पहचान

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

एआई वर्गीकरण	पहचान
ब्लूबीनबैग	0
रेडबीनबैग	1
येलोबीनबैग	2

def main():
    # Drop the preloaded Bean Bag
    intake_motor.spin_for(REVERSE, 180, DEGREES)
    drivetrain.turn_for(LEFT, 90, DEGREES)

    # Pick up the Bean Bag if it's red
    drivetrain.set_drive_velocity(30, PERCENT)
    ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
    for ai_object in ai_objects:
        if ai_object.id == GameElements.RED_BEANBAG:
            intake_motor.spin(FORWARD)
            drivetrain.drive_for(FORWARD, 150, MM)
            break

# VR threads — Do not delete
vr_thread(main)

---

def main():
    # Stop when you see the Red Goal
    drivetrain.set_turn_velocity(30, PERCENT)
    drivetrain.turn(RIGHT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_TAGS)
        for ai_object in ai_objects:
            if ai_object.id == 1:
                drivetrain.stop()
                brain.screen.print("Found the Red Goal!")
                return

# VR threads — Do not delete
vr_thread(main)