Python específico para robots#
Introducción#
El Hero Bot, Flex, incluye un motor de garra, un motor de brazo, un sensor de visión con IA, un sensor de distancia y un sensor de sistema de posicionamiento de juego (GPS).
Todos los métodos VEXcode VR estándar están disponibles para su uso en el V5 26-27 Override Playground.
A continuación se muestra una lista de todos los métodos disponibles específicos para Robot:
Sistema de transmisión: Mover y girar el robot.
Comportamiento
drive— Mueve el robot hacia adelante o hacia atrás indefinidamente.drive_for— Mueve el robot hacia adelante o hacia atrás una distancia específica.turn— Gira el robot a la izquierda o a la derecha indefinidamente.turn_for— Gira el robot hacia la izquierda o hacia la derecha un número específico de grados.turn_to_heading— Gira el robot para que mire hacia una dirección específica de -359 a 359 grados.turn_to_rotation— Gira el robot a una rotación específica.stop— Detiene el movimiento del robot.
Mutadores
set_heading— Cambia el rumbo actual del robot a un nuevo rumbo.set_rotation— Cambia la rotación actual del robot a una nueva rotación.set_timeout— Establece cuánto tiempo intentará el robot terminar un movimiento.set_drive_velocity— Indica al robot a qué velocidad debe conducir.set_turn_velocity— Indica al robot a qué velocidad debe girar.
Obtenidos
heading— Devuelve la dirección actual del robot de 0 a 359,99 grados.rotation— Devuelve la rotación actual del robot.is_done— Devuelve si el robot ha terminado de moverse, como un valor booleano.is_moving— Devuelve si el robot se está moviendo, como un valor booleano.velocity— Devuelve la velocidad a la que se desplaza el robot.
Movimiento: Mueve y rastrea los motores del robot.
Comportamiento
spin— Hace girar un motor hacia adelante o hacia atrás indefinidamente.spin_for— Hace girar un motor durante una distancia específica.spin_to_position— Hace girar un motor a una posición específica.stop— Detiene el giro de un motor.
Mutadores
set_position— Cambia la posición actual del motor a un nuevo valor.set_velocity— Indica a un motor a qué velocidad debe girar.set_timeout— Establece cuánto tiempo intentará un motor terminar un movimiento.
Obtenidos
is_done— Devuelve si el motor ha terminado de moverse, como un valor booleano.is_spinning— Devuelve si el motor está girando, como un valor booleano.position— Devuelve la posición actual del motor.velocity— Devuelve la velocidad de giro del motor.
Visión por IA: Captura y analiza objetos utilizando el sensor de visión por IA.
Obtenidos
take_snapshot– Devuelve una tupla de objetos detectados para una firma específica.
Propiedades
.width– Ancho del objeto detectado en píxeles..height– Altura del objeto detectado en píxeles..centerX– Posición X del centro del objeto en píxeles..centerY– Posición Y del centro del objeto en píxeles..originX– Posición X de la esquina superior izquierda del objeto en píxeles..originY– Posición Y de la esquina superior izquierda del objeto en píxeles..id– ID de clasificación del objeto detectado.
Consola: Imprime en la consola y monitoriza los valores.
Imprimir
brain.screen.print— Muestra texto, números o valores de variables en la consola.brain.screen.next_row— Mueve el cursor de la consola al inicio de la siguiente fila.brain.screen.clear_screen— Borra todas las filas de la consola.
Monitor
monitor_variable— Agrega una o más variables predefinidas a la pestaña Monitor.monitor_sensor— Agrega uno o más valores de sensor a la pestaña Monitor.
Detección: Utilice los diversos sensores del robot.
Distancia
found_object– Devuelve si el sensor de distancia detecta un objeto dentro del rango.object_distance– Devuelve la distancia entre el sensor de distancia y el objeto detectado más cercano.
GPS
x_position– Devuelve la coordenada x actual del sensor GPS en el campo.y_position– Devuelve la coordenada y actual del sensor GPS en el campo.heading– Devuelve la dirección hacia la que apunta actualmente el robot según el sensor GPS.
Los ejemplos de esta página utilizan la ubicación de inicio C de la lista de verificación previa al partido del Playground.
Tren de transmisión#
El sistema de transmisión controla cómo se desplaza y gira el robot de realidad virtual. Este sistema puede avanzar o retroceder, girar a la izquierda o a la derecha, orientarse y seguir su propio movimiento de rotación.
Comportamiento#
conducir#
La acción drive indefinidamente. El robot continuará moviéndose hasta que se le indique otra acción, como girar o detenerse.
Usage:
drivetrain.drive(direction)
Parámetros |
Descripción |
|---|---|
|
La dirección en la que se mueve el robot: |
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)
impulso_por#
drive_for mueve el robot hacia adelante o hacia atrás una distancia específica. El proyecto esperará hasta que el robot termine de moverse antes de ejecutar la siguiente línea de código.
Usage:
drivetrain.drive_for(direction, distance, units, wait)
Parámetros |
Descripción |
|---|---|
|
La dirección en la que se mueve el robot: |
|
La distancia que recorre el robot. Puede ser un entero |
|
Opcional. La unidad de distancia: |
|
Opcional. |
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)
doblar#
turn hace que el robot gire a la izquierda o a la derecha indefinidamente. El robot seguirá girando hasta que se le dé otra acción, como conducir o detenerse.
Usage:
drivetrain.turn(direction)
Parámetros |
Descripción |
|---|---|
|
La dirección en la que gira el robot: |
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)
turno_para#
turn_for hace girar el robot hacia la izquierda o hacia la derecha un número específico de grados. El giro es relativo a la posición actual del robot. El programa esperará a que el robot termine de girar antes de ejecutar la siguiente línea de código.
Usage:
drivetrain.turn_for(direction, angle, units, wait)
Parámetros |
Descripción |
|---|---|
|
La dirección en la que gira el robot: |
|
El número de grados que gira el robot. Puede ser un entero |
|
Opcional. Unidad de ángulo: |
|
Opcional. |
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)
girar_hacia_rumbo#
El rumbo indica la dirección hacia la que apunta el robot, medida en grados. turn_to_heading hace que el robot gire para apuntar a un rumbo específico, desde -359 hasta 359 grados. El robot girará en la dirección más corta para alcanzar el rumbo deseado.
El rumbo inicial es de 0 grados.
Usage:
drivetrain.turn_to_heading(heading, units, wait)
Parámetros |
Descripción |
|---|---|
|
La dirección hacia la que debe apuntar el robot, desde -359 hasta 359 grados. |
|
Opcional. Unidad de ángulo: |
|
Opcional. |
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)
girar_a_rotación#
turn_to_rotation gira el robot a una rotación específica.
La rotación indica cuánto ha girado el robot, medida en grados. Al inicio de un proyecto, el valor de rotación se establece en 0 grados. Girar a la derecha aumenta la rotación, y girar a la izquierda la disminuye.
Por ejemplo, si el robot parte de 0 grados y gira 720 grados, dará dos vueltas a la derecha. Si luego gira 360 grados, dará una vuelta a la izquierda, ya que 360 es menor que 720.
Usage:
drivetrain.turn_to_rotation(rotation, units, wait)
Parámetros |
Descripción |
|---|---|
|
El valor de rotación, en grados, al que girará el robot. Puede ser un entero |
|
Opcional. Unidad de ángulo: |
|
Opcional. |
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)
detener#
stop detiene el movimiento del robot.
Usage:
drivetrain.stop()
Parámetros |
Descripción |
|---|---|
Este método no tiene parámetros. |
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)
Mutadores#
establecer_encabezado#
Un rumbo es la dirección hacia la que apunta el robot, medida en grados. set_heading cambia el rumbo actual del robot a un nuevo valor de rumbo.
Por ejemplo, si el robot ha girado para mirar hacia la derecha, al establecer la orientación a 0 grados, esa posición mirando hacia la derecha se convierte en la nueva posición de 0 grados. Entonces, el robot puede girar a otras posiciones en función de esa nueva orientación.
Usage:
drivetrain.set_heading(heading, units)
Parámetros |
Descripción |
|---|---|
|
El valor de rumbo, en grados, que se debe establecer para el robot. |
|
Opcional. Unidad de ángulo: |
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)
establecer_rotación#
La rotación es cuánto ha girado el robot, medido en grados. set_rotation cambia la rotación actual del robot a un nuevo valor.
Usage:
drivetrain.set_rotation(rotation, units)
Parámetros |
Descripción |
|---|---|
|
El valor de rotación, en grados, que se establecerá para el robot. Puede ser un entero |
|
Opcional. Unidad de ángulo: |
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)
establecer_tiempo_de_espera#
El parámetro set_timeout establece cuántos segundos intentará el robot completar un movimiento. Si no lo logra en ese tiempo, dejará de intentarlo y pasará a la siguiente línea de código. Esto evita que el robot se quede atascado en un movimiento.
Usage:
drivetrain.set_timeout(time, units)
Parámetros |
Descripción |
|---|---|
|
El número de segundos que el robot puede intentar para terminar un movimiento. Puede ser un entero positivo |
|
Opcional. La unidad de tiempo: |
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)
establecer_velocidad_de_conducción#
El valor set_drive_velocity indica al robot la velocidad a la que debe conducir. Un porcentaje mayor hace que el robot conduzca más rápido y un porcentaje menor hace que conduzca más lento.
Todos los proyectos comienzan con el robot conduciendo al 50% de su velocidad por defecto.
Nota: Una mayor velocidad hace que el robot se desplace más rápido, pero puede ser menos preciso. Una menor velocidad hace que el robot se desplace más despacio, pero puede ser más preciso.
Usage:
drivetrain.set_drive_velocity(velocity, units)
Parámetros |
Descripción |
|---|---|
|
La velocidad a conducir de 0% a 100%. Puede ser un entero |
|
Opcional. Unidad de velocidad: |
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)
establecer_velocidad_de_giro#
El valor set_turn_velocity indica al robot la velocidad de giro. Un porcentaje mayor hace que el robot gire más rápido y un porcentaje menor hace que gire más lento.
Todos los proyectos comienzan con el robot girando al 50% de su velocidad por defecto.
Nota: Una mayor velocidad hace que el robot gire más rápido, pero puede ser menos preciso. Una menor velocidad hace que el robot gire más despacio, pero puede ser más preciso.
Usage:
drivetrain.set_turn_velocity(velocity, units)
Parámetros |
Descripción |
|---|---|
|
La velocidad de giro va del 0% al 100%. Puede ser un entero |
|
Opcional. Unidad de velocidad: |
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)
Getters#
título#
El rumbo es la dirección hacia la que apunta el robot, medida en grados. heading devuelve el rumbo actual del robot, que va de 0 a 359,99 grados.
La dirección inicial del robot es de 0 grados.
Usage:
drivetrain.heading(units)
Parámetros |
Descripción |
|---|---|
|
Opcional. Unidad de rumbo: |
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)
rotación#
La rotación indica cuánto ha girado el robot, medida en grados. Al inicio de un proyecto, el valor de rotación se establece en 0 grados. rotation devuelve la rotación actual del robot.
Girar a la derecha aumenta la rotación, y girar a la izquierda la disminuye. Por ejemplo, dar dos vueltas completas a la derecha produce una rotación de 720 grados.
Usage:
drivetrain.rotation(units)
Parámetros |
Descripción |
|---|---|
|
Opcional. Unidad de rotación: |
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)
está_hecho#
is_done devuelve un valor booleano que indica si el robot ha terminado de moverse. Esto se puede usar para controlar la sincronización de otros comportamientos en función del movimiento del robot.
True— El robot ha terminado de moverse.False— El robot sigue moviéndose.
Este método funciona junto con los siguientes métodos de Drivetrain que tienen el parámetro wait : drive_for, turn_for, turn_to_heading, y turn_to_rotation.
Usage:
drivetrain.is_done()
Parámetros |
Descripción |
|---|---|
Este método no tiene parámetros. |
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)
se está moviendo#
is_moving devuelve un valor booleano que indica si el robot se está moviendo. Esto se puede usar para controlar la sincronización de otros comportamientos en función del movimiento del robot.
True— El robot se está moviendo.False— El robot no se está moviendo.
Usage:
drivetrain.is_moving()
Parámetros |
Descripción |
|---|---|
Este método no tiene parámetros. |
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)
velocidad#
velocity devuelve la velocidad a la que se desplaza el robot, como un porcentaje de -100% a 100%.
Usage:
drivetrain.velocity(units)
Parámetros |
Descripción |
|---|---|
|
Opcional. Unidad de velocidad: |
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)
Movimiento#
Flex utiliza el motor del brazo para levantar y bajar el brazo, y el motor de la garra para abrir y cerrar la garra.
Cada motor tiene su propio comportamiento direccional. Las descripciones de las direcciones explican cómo se mueve cada motor en Flex.
Comportamiento#
girar#
El comando spin hace girar un motor en una de dos direcciones indefinidamente. El motor seguirá girando hasta que se le aplique otra acción, como girar en una dirección diferente o detenerse.
Uso:
Se puede utilizar uno de los dos objetos de motor disponibles con este método, como se muestra a continuación:
motor |
Dominio |
|---|---|
|
|
|
|
Parámetros |
Descripción |
|---|---|
|
Dirección de giro del motor:
|
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)
girar_para#
spin_for hace girar un motor una distancia específica. El giro es relativo a la posición actual del motor. El proyecto esperará a que el motor termine de girar antes de ejecutar la siguiente línea de código.
Uso:
Se puede utilizar uno de los dos objetos de motor disponibles con este método, como se muestra a continuación:
motor |
Dominio |
|---|---|
|
|
|
|
Parámetros |
Descripción |
|---|---|
|
Dirección de giro del motor:
|
|
La distancia que gira el motor. |
|
Opcional. La unidad de distancia: |
|
Opcional.
|
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)
girar_a_posición#
spin_to_position hace girar un motor a una posición específica.
La posición de un motor es cuánto ha girado, medido en DEGREES o TURNSUna vuelta equivale a 360 grados. Al inicio de un proyecto, la posición del motor del brazo se establece en 0 grados. El motor de la garra es la excepción: comienza en 467 grados (completamente cerrado). La posición del motor también se puede establecer utilizando el método set_position.
Los valores de posición son absolutos. Esto significa que la dirección de giro depende de la posición actual del motor.
Por ejemplo, si el motor parte de 0 grados y gira hasta una posición de 720 grados, girará dos vueltas hacia adelante. Si luego gira hasta una posición de 360 grados, girará una vuelta hacia atrás, ya que 360 es menor que 720.
Uso:
Se puede utilizar uno de los dos objetos de motor disponibles con este método, como se muestra a continuación:
motor |
Dominio |
|---|---|
|
|
|
|
Parámetros |
Descripción |
|---|---|
|
El valor de posición al que girará el motor. |
|
Opcional. La unidad de posición: |
|
Opcional.
|
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)
detener#
stop detiene el giro de un motor.
Uso:
Se puede utilizar uno de los dos objetos de motor disponibles con este método, como se muestra a continuación:
motor |
Dominio |
|---|---|
|
|
|
|
Parámetros |
Descripción |
|---|---|
Este método no tiene parámetros. |
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)
Mutadores#
posición_de_establecer#
La posición de un motor es cuánto ha girado, medido en DEGREES o TURNSUna vuelta es igual a 360 grados. set_position cambia la posición actual del motor a un nuevo valor.
Por ejemplo, si un motor ha girado 180 grados, al ajustar la posición a 0 grados, dicha posición volverá a su estado original. A partir de ahí, el motor podrá girar a posiciones que dependan de ese nuevo valor.
Uso:
Se puede utilizar uno de los dos objetos de motor disponibles con este método, como se muestra a continuación:
motor |
Dominio |
|---|---|
|
|
|
|
Parámetros |
Descripción |
|---|---|
|
El valor de posición que se debe establecer para el motor. |
|
Opcional. La unidad de posición: |
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)
establecer_velocidad#
El valor set_velocity indica a un motor qué tan rápido debe girar. Un porcentaje mayor hace que el motor gire más rápido y un porcentaje menor hace que gire más lento.
Cada proyecto comienza con cada motor girando al 50% de su velocidad máxima por defecto.
Nota: Una mayor velocidad hace que el motor gire más rápido, pero puede ser menos preciso. Una menor velocidad hace que el motor gire más lento, pero puede ser más preciso.
Uso:
Se puede utilizar uno de los dos objetos de motor disponibles con este método, como se muestra a continuación:
motor |
Dominio |
|---|---|
|
|
|
|
Parámetros |
Descripción |
|---|---|
|
La velocidad de giro va del 0% al 100%. Puede ser un entero |
|
La unidad de velocidad: |
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)
establecer_tiempo_de_espera#
set_timeout establece cuánto tiempo intentará un motor completar un movimiento. Si el motor no puede terminar en ese tiempo, dejará de intentarlo y pasará a la siguiente línea de código. Esto evita que el motor se quede atascado en un movimiento.
Uso:
Se puede utilizar uno de los dos objetos de motor disponibles con este método, como se muestra a continuación:
motor |
Dominio |
|---|---|
|
|
|
|
Parámetros |
Descripción |
|---|---|
|
La cantidad de tiempo que el motor puede intentar para completar un movimiento. Esto puede ser un entero positivo |
|
La unidad de tiempo: |
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)
Getters#
está_hecho#
is_done devuelve un valor booleano que indica si el motor ha terminado de moverse. Esto se puede usar para controlar la sincronización de otros comportamientos en función del movimiento del motor.
True— El motor ha terminado de moverse.False— El motor sigue en movimiento.
Este método funciona junto con los siguientes métodos de movimiento que tienen el parámetro wait : spin_for y spin_to_position.
Uso:
Se puede utilizar uno de los dos objetos de motor disponibles con este método, como se muestra a continuación:
motor |
Dominio |
|---|---|
|
|
|
|
Parámetros |
Descripción |
|---|---|
Este método no tiene parámetros. |
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)
está_girando#
is_spinning devuelve un valor booleano que indica si el motor está girando. Esto se puede usar para controlar la sincronización de otros comportamientos en función del movimiento del motor.
True— El motor está girando.False— El motor no está girando.
Este método funciona junto con los siguientes métodos de movimiento que tienen el parámetro wait : spin_for y spin_to_position.
Uso:
Se puede utilizar uno de los dos objetos de motor disponibles con este método, como se muestra a continuación:
motor |
Dominio |
|---|---|
|
|
|
|
Parámetros |
Descripción |
|---|---|
Este método no tiene parámetros. |
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)
posición#
La posición de un motor es cuánto ha girado, medido en DEGREES o TURNSUna vuelta es igual a 360 grados. position devuelve la posición actual del motor.
Al inicio de un proyecto, la posición del motor del brazo se establece en 0 grados. El motor de la garra es la excepción: comienza en 467 grados (completamente cerrado). Si el motor gira una vuelta completa hacia adelante, la posición aumenta. Si gira en sentido contrario, la posición disminuye.
Uso:
Se puede utilizar uno de los dos objetos de motor disponibles con este método, como se muestra a continuación:
motor |
Dominio |
|---|---|
|
|
|
|
Parámetros |
Descripción |
|---|---|
|
La unidad para devolver la posición del motor en: |
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)
velocidad#
velocity devuelve la velocidad de giro del motor.
Un valor positivo significa que el motor gira hacia adelante. Un valor negativo significa que el motor gira hacia atrás.
Uso:
Se puede utilizar uno de los dos objetos de motor disponibles con este método, como se muestra a continuación:
motor |
Dominio |
|---|---|
|
|
|
|
Parámetros |
Descripción |
|---|---|
|
La unidad de velocidad a devolver: |
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)
Visión por IA#
Getters#
tomar_instantánea#
take_snapshot filtra los datos del fotograma del sensor de visión de IA a una única firma (una descripción guardada de algo que el sensor puede reconocer, como un elemento del juego en el campo) y devuelve una tupla.
The tuple stores objects ordered from largest to smallest by width, starting at index 0. Each object’s properties can be accessed using its index. An empty tuple is returned if no matching objects are detected.
Usage:
ai_vision.take_snapshot(signature)
Parámetros |
Descripción |
|---|---|
|
Filtra el conjunto de datos para incluir solo datos de la firma dada. Las firmas disponibles son:
|
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)
Propiedades#
Hay siete propiedades que se incluyen con cada objeto almacenado en una tupla después de que se utiliza take_snapshot.
Todos los valores de propiedad excepto .id describen la posición y el tamaño del objeto detectado en la vista del sensor de visión de IA en el momento en que se usó take_snapshot Estos valores se miden en píxeles, según la resolución de 320 por 240 píxeles del sensor.
.ancho#
.width devuelve el ancho del objeto detectado en píxeles, que es un número entero entre 1 y 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)
.altura#
.height devuelve la altura del objeto detectado en píxeles, que es un número entero entre 1 y 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#
.centerX devuelve la coordenada x del centro del objeto detectado en píxeles, que es un número entero entre 0 y 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)
.centroY#
.centerY devuelve la coordenada y del centro del objeto detectado en píxeles, que es un número entero entre 0 y 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 devuelve la coordenada x de la esquina superior izquierda del cuadro delimitador del objeto detectado en píxeles, que es un número entero entre 0 y 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)
.origenY#
.originY devuelve la coordenada y de la esquina superior izquierda del cuadro delimitador del objeto detectado en píxeles, que es un número entero entre 0 y 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)
.identificación#
.id devuelve el ID de la clasificación de IA detectada como un número entero.
Clasificación de IA |
identificación |
Firma |
|---|---|---|
Pin rojo y azul |
0 |
|
Pin azul y amarillo |
1 |
|
RojoYellowPin |
2 |
|
YellowPin |
3 |
|
Taza |
4 |
|
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)
Consola#
La consola muestra texto, números y valores de variables mientras se ejecuta un proyecto. Los métodos de la consola también permiten mover el cursor a una nueva fila, borrar la consola y agregar variables o valores de sensores a la pestaña Monitor.
Imprimir#
pantalla del cerebro impresión#
brain.screen.print muestra texto, números o valores de variables en la consola utilizando la posición actual del cursor.
Utilice brain.screen.next_row cuando desee que el siguiente valor impreso comience en una nueva fila.
Usage:
brain.screen.print(value)
Parámetros |
Descripción |
|---|---|
|
El texto, número o valor de variable que se mostrará en la consola. |
def main():
# Display a message in the Console
brain.screen.print("Hello, robot!")
# VR threads — Do not delete
vr_thread(main)
pantalla.siguiente_fila#
brain.screen.next_row mueve el cursor a la columna 1 en la siguiente fila de la consola. El siguiente valor impreso aparecerá en esa fila.
Usage:
brain.screen.next_row()
Parámetros |
Descripción |
|---|---|
Este método no tiene parámetros. |
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)
pantalla.cerebro.pantalla_limpia#
brain.screen.clear_screen borra todas las filas de la consola y mueve el cursor de vuelta a la fila 1.
Usage:
brain.screen.clear_screen()
Parámetros |
Descripción |
|---|---|
Este método no tiene parámetros. |
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_de_monitor#
monitor_variable agrega una o más variables predefinidas a la pestaña Monitor en VEXcode. Esto le permite observar cómo cambia el valor de una variable mientras se ejecuta un proyecto.
Las variables deben ser globales para que monitor_variable pueda monitorizarlas correctamente. Proporcione el nombre de cada variable como una cadena.
Usage:
monitor_variable(“variable”)
monitor_variable(“variable1”, “variable2”)
Parámetros |
Descripción |
|---|---|
|
El nombre de una variable global predefinida que se desea monitorizar, especificado como una cadena de texto. Para monitorizar más de una variable, separe cada nombre con una coma. |
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)
sensor_de_monitor#
monitor_sensor agrega uno o más valores de sensor a la pestaña Monitor en VEXcode. Esto le permite observar cómo cambian los valores de los sensores mientras se ejecuta un proyecto.
Proporcione cada valor del sensor como una cadena de texto.
Usage:
monitor_sensor(“sensor”)
monitor_sensor(“sensor1”, “sensor2”)
Parámetros |
Descripción |
|---|---|
|
The sensor value to monitor, given as a string. To monitor more than one sensor value, separate each sensor value with a comma. Supported sensor identifiers include:
|
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)
Detección#
Distancia#
objeto_encontrado#
found_object devuelve si el sensor de distancia detecta actualmente un objeto dentro de 2000 mm.
True— El sensor de distancia detecta un objeto.False— El sensor de distancia no detecta ningún objeto.
Usage:
distance.found_object()
Parámetros |
Descripción |
|---|---|
Este método no tiene parámetros. |
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)
distancia_del_objeto#
object_distance devuelve la distancia entre el sensor de distancia y el objeto detectado más cercano.
Usage:
distance.object_distance(units)
Parámetros |
Descripción |
|---|---|
|
La unidad de distancia: |
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#
posición_x#
x_position devuelve la coordenada x actual de un sensor GPS (Game Positioning System™) en el campo.
Usage:
gps.x_position(units)
Parámetros |
Descripción |
|---|---|
unidades |
Unidad del valor de desplazamiento: |
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)
posición_y#
y_position devuelve la coordenada y actual de un sensor GPS (Game Positioning System™) en el campo.
Usage:
gps.y_position(units)
Parámetros |
Descripción |
|---|---|
unidades |
Unidad del valor de desplazamiento: |
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)
título#
heading devuelve la dirección hacia la que apunta actualmente el robot según las lecturas del sensor GPS (Game Positioning System™) de 0 a 359 grados.
Usage:
gps.heading()
Parámetros |
Descripción |
|---|---|
Este método no tiene parámetros. |
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)