റോബോട്ട്-നിർദ്ദിഷ്ട പൈത്തൺ#

ആമുഖം#

ഹീറോ ബോട്ട്, ഫ്ലോപ്പിൽ ഒരു ഇന്റേക്ക് മോട്ടോർ, ഒരു ആം മോട്ടോർ, ഒരു ഐക്യു എഐ വിഷൻ സെൻസർ എന്നിവ ഉൾപ്പെടുന്നു.

IQ 26-27 ലെവൽ അപ്പ് പ്ലേഗ്രൗണ്ടിൽ ഉപയോഗിക്കാൻ എല്ലാ സ്റ്റാൻഡേർഡ് VEXcode VR പൈത്തൺ കമാൻഡുകളും ലഭ്യമാണ്.

ലഭ്യമായ എല്ലാ റോബോട്ട്-നിർദ്ദിഷ്ട പൈത്തൺ കമാൻഡുകളുടെയും ഒരു ലിസ്റ്റ് താഴെ കൊടുക്കുന്നു:

ചലനം – റോബോട്ടിന്റെ മോട്ടോറുകൾ നീക്കി ട്രാക്ക് ചെയ്യുക.

  • പ്രവർത്തനങ്ങൾ

    • സ്പിൻ – ഒരു മോട്ടോർ ഒരു ദിശയിലേക്ക് എന്നെന്നേക്കുമായി കറക്കുന്നു.

    • spin_for – ഒരു മോട്ടോർ ഒരു നിശ്ചിത എണ്ണം ഡിഗ്രികൾക്കോ ​​തിരിവുകൾക്കോ ​​കറക്കുന്നു.

    • സ്ഥാനത്തേക്ക്_സ്പിൻ ചെയ്യുക – ഒരു മോട്ടോർ ഒരു പ്രത്യേക സ്ഥാനത്തേക്ക് കറക്കുന്നു.

    • നിർത്തുക – ഒരു മോട്ടോർ കറങ്ങുന്നത് തടയുന്നു.

  • ക്രമീകരണങ്ങൾ

    • set_velocity – ഒരു മോട്ടോർ എത്ര വേഗത്തിൽ കറങ്ങുമെന്ന് സജ്ജമാക്കുന്നു.

    • set_timeout – ഒരു മോട്ടോർ ഒരു ചലനം പൂർത്തിയാക്കാൻ എത്ര സമയം ശ്രമിക്കുമെന്ന് സജ്ജമാക്കുന്നു.

    • set_position – മോട്ടോറിന്റെ നിലവിലെ സ്ഥാനം ഒരു പുതിയ മൂല്യത്തിലേക്ക് മാറ്റുന്നു.

  • മൂല്യങ്ങൾ

    • പൂർത്തിയായി – മോട്ടോർ ചലിച്ചു കഴിഞ്ഞോ എന്ന് നൽകുന്നു.

    • സ്പിന്നിംഗ് – മോട്ടോർ കറങ്ങുന്നുണ്ടോ എന്ന് നൽകുന്നു.

    • സ്ഥാനം – മോട്ടോറിന്റെ നിലവിലെ സ്ഥാനം നൽകുന്നു.

    • വേഗത – മോട്ടോർ എത്ര വേഗത്തിൽ കറങ്ങുന്നുവെന്ന് നൽകുന്നു.

AI വിഷൻ - IQ AI വിഷൻ സെൻസർ ഉപയോഗിച്ച് വസ്തുക്കൾ പകർത്തി വിശകലനം ചെയ്യുക.

  • നേടുന്നവർ

    • take_snapshot – സെൻസറിന്റെ നിലവിലെ ഫ്രെയിമിനെ ഒരു പ്രത്യേക സിഗ്നേച്ചറിലേക്ക് ഫിൽട്ടർ ചെയ്യുകയും കണ്ടെത്തിയ വസ്തുക്കളുടെ ഒരു ട്യൂപ്പിൾ തിരികെ നൽകുകയും ചെയ്യുന്നു.

  • പ്രോപ്പർട്ടികൾ

    • .width – കണ്ടെത്തിയ വസ്തുവിന്റെ വീതി പിക്സലുകളിൽ നൽകുന്നു.

    • .height – കണ്ടെത്തിയ വസ്തുവിന്റെ ഉയരം പിക്സലുകളിൽ നൽകുന്നു.

    • .centerX – കണ്ടെത്തിയ വസ്തുവിന്റെ മധ്യഭാഗത്തിന്റെ x-കോർഡിനേറ്റ് നൽകുന്നു.

    • .centerY – കണ്ടെത്തിയ വസ്തുവിന്റെ മധ്യഭാഗത്തിന്റെ y-കോർഡിനേറ്റ് നൽകുന്നു.

    • .originX – കണ്ടെത്തിയ വസ്തുവിന്റെ ബൗണ്ടിംഗ് ബോക്സിന്റെ മുകളിൽ ഇടത് കോണിലുള്ള x-കോർഡിനേറ്റ് നൽകുന്നു.

    • .originY – കണ്ടെത്തിയ വസ്തുവിന്റെ ബൗണ്ടിംഗ് ബോക്സിന്റെ മുകളിൽ ഇടത് കോണിലുള്ള y-കോർഡിനേറ്റ് നൽകുന്നു.

    • .id – കണ്ടെത്തിയ AI വർഗ്ഗീകരണത്തിന്റെ ഐഡി നൽകുന്നു.

ഈ പേജിലെ ഉദാഹരണങ്ങൾ ഡിഫോൾട്ട് പ്ലേഗ്രൗണ്ട് ആരംഭ സ്ഥാനം ഉപയോഗിക്കുന്നു.

ചലനം#

ഫ്ലോപ്പിന് രണ്ട് റോബോട്ട്-നിർദ്ദിഷ്ട മോട്ടോറുകളുണ്ട്: intake_motor ഉം arm_motor. രണ്ടും സ്റ്റാൻഡേർഡ് മോട്ടോർ കമാൻഡുകൾ ഉപയോഗിക്കുന്നു.

ദിശാ സ്ഥിരാങ്കങ്ങൾ:

  • intake_motor: FORWARD = intake (ശേഖരിക്കുന്നു); REVERSE = outtake (പുറന്തള്ളുന്നു)

  • 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 മോട്ടോർ നിലവിൽ കറങ്ങുന്നുണ്ടോ എന്ന് സൂചിപ്പിക്കുന്ന ഒരു ബൂളിയൻ നൽകുന്നു.

  • 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 ഒഴികെയുള്ള എല്ലാ പ്രോപ്പർട്ടി മൂല്യങ്ങളും take_snapshot ഉപയോഗിച്ച സമയത്ത് IQ AI വിഷൻ സെൻസറിന്റെ വ്യൂവിൽ കണ്ടെത്തിയ വസ്തുവിന്റെ സ്ഥാനവും വലുപ്പവും വിവരിക്കുന്നു. സെൻസറിന്റെ 320 ബൈ 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 കണ്ടെത്തിയ വസ്തുവിന്റെ ബൗണ്ടിംഗ് ബോക്സിന്റെ മുകളിൽ ഇടത് കോണിലുള്ള 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 കണ്ടെത്തിയ വസ്തുവിന്റെ ബൗണ്ടിംഗ് ബോക്സിന്റെ മുകളിൽ ഇടത് കോണിലുള്ള 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 കണ്ടെത്തിയ AI ക്ലാസിഫിക്കേഷന്റെ ഐഡി ഒരു പൂർണ്ണസംഖ്യയായി നൽകുന്നു.

AI വർഗ്ഗീകരണം

ഐഡി

ബ്ലൂബീൻബാഗ്

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)
On this page