Movimiento#

Introducción #

Los motores controlan cómo se mueven las partes de un robot. Los motores se pueden usar para levantar un brazo, girar una garra, girar una rueda o mover otra parte de una construcción. Dos motores pueden trabajar juntos como un tren motriz para mover y girar todo el robot.

Cada motor está configurado en la ventana Dispositivos. Dependiendo de la compilación, los nombres de los motores pueden cambiar. Por ejemplo, la compilación Competition Advanced 2.0 tiene un motor llamado arm_motor. Un robot personalizado puede usar diferentes nombres de motores.

De forma predeterminada, el FORWARD hace girar un motor en sentido antihorario y el REVERSE hace girar un motor en sentido horario. Si un motor está configurado para retroceder en la ventana Dispositivos, esas direcciones se cambiarán.

Un motor VEX GO que muestra la dirección hacia adelante indicada por un signo más y una flecha que indica que está girando a la izquierda o en sentido contrario a las agujas del reloj.

Un motor VEX GO que muestra la dirección inversa indicada por un signo menos y una flecha que indica que está girando a la derecha o en el sentido de las agujas del reloj.

Hay muchas maneras de codificar motores. A continuación se muestra una lista de todos los métodos de Motion:

Acciones — Motores de parada y giro.

spin — Hace girar un motor hacia adelante o hacia atrás para siempre.
spin_for — Hace girar un motor para 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: ajuste la configuración del motor.

set_velocity — Le dice a un motor qué tan rápido debe girar.
set_max_torque — Establece la fuerza con la que se permite que un motor empuje mientras gira.
set_position — Cambia la posición actual del motor a un nuevo valor.
set_stopping — Establece cómo un motor dejará de moverse: frenando, deslizándose o sosteniéndose.
set_timeout — Establece cuánto tiempo intentará un motor terminar un movimiento.

Getters — Compruebe el estado del motor.

get_position — Devuelve la posición actual del motor.
get_velocity — Devuelve la velocidad a la que gira el motor, como un porcentaje de -100% a 100%.
get_current — Devuelve la cantidad de energía que el motor está usando de la batería, como un porcentaje de 0% a 100%.
is_stopped — Devuelve si el motor ha terminado de moverse, como un valor booleano.
is_moving — Devuelve si el motor está girando, como un valor booleano.

Acciones #

spin #

spin hace girar un motor hacia adelante o hacia atrás para siempre. El motor continuará girando hasta que se le dé otra acción, como girar en una dirección diferente o detenerse.

Usage:
arm_motor.spin(direction)

Parámetros	Descripción
`direction`	La dirección en la que gira el motor: `FORWARD` O HACIA `REVERSE`.

# Build Used: Competition Advanced 2.0
def main():
    # Raise the ArmMotor, then stop
    arm_motor.spin(REVERSE)
    wait(1, SECONDS)
    arm_motor.stop()

# Start threads — Do not delete
start_thread(main)

spin_for #

spin_for hace girar un motor para una distancia específica. El giro es relativo a la posición actual del motor. El proyecto esperará hasta que el motor termine de girar antes de que se ejecute la siguiente línea de código.

Usage:
arm_motor.spin_for(direction, angle, units, wait)

Parámetros	Descripción
`direction`	La dirección en la que gira el motor: `FORWARD` O HACIA `REVERSE`.
`angle`	La distancia que gira el motor. `DEGREES` usar números enteros. `TURNS` puede usar números enteros o decimales.
`units`	Opcional. La unidad de distancia: `DEGREES` (predeterminado) o `TURNS`.
`wait`	Opcional. `wait=True` (predeterminado) hace que el proyecto espere hasta que el motor termine de girar antes de que se ejecute la siguiente línea de código. `wait=False` hace que la siguiente línea de código se ejecute de inmediato.

# Build Used: Competition Advanced 2.0
def main():
    # Raise and lower the ArmMotor
    arm_motor.spin_for(REVERSE, 180, DEGREES)
    wait(1, SECONDS)
    arm_motor.spin_for(FORWARD, 180, DEGREES)

# Start threads — Do not delete
start_thread(main)

spin_to_position #

spin_to_position hace girar un motor a una posición específica.

La posición de un motor es la distancia a la que ha girado, medida en DEGREES o TURNS. Un giro equivale a 360 grados. Al comienzo de un proyecto, la posición del motor se establece en 0 grados. La posición del motor también se puede configurar utilizando el método set_position.

Los valores de posición son absolutos. Esto significa que la dirección del giro depende de la posición actual del motor.

Por ejemplo, si el motor arranca a 0 grados y gira a una posición de 720 grados, girará hacia adelante dos vueltas. Si luego gira a una posición de 360 grados, girará en reversa una vuelta, porque 360 es menos de 720.

Usage:
arm_motor.spin_to_position(angle, units, wait)

Parámetros	Descripción
`angle`	El valor de posición al que girará el motor. `DEGREES` usar enteros. `TURNS` puede usar enteros o decimales.
`units`	Opcional. La unidad de posición: `DEGREES` (predeterminado) o `TURNS`.
`wait`	Opcional. `wait=True` (predeterminado) hace que el proyecto espere hasta que el motor termine de girar antes de que se ejecute la siguiente línea de código. `wait=False` hace que la siguiente línea de código se ejecute de inmediato.

# Build Used: Competition Advanced 2.0
def main():
    # Return ArmMotor to 0 degrees after raising
    arm_motor.spin_for(REVERSE, 180, DEGREES)
    wait(1, SECONDS)
    arm_motor.spin_to_position(0, DEGREES)

# Start threads — Do not delete
start_thread(main)

stop #

stop detiene el giro de un motor.

Usage:
arm_motor.stop()

Parámetros	Descripción
	Este método no tiene parámetros.

# Build Used: Competition Advanced 2.0
def main():
    # Raise the ArmMotor
    arm_motor.spin(REVERSE)
    wait(1, SECONDS)
    arm_motor.stop()

# Start threads — Do not delete
start_thread(main)

Mutadores #

set_velocity #

set_velocity le dice a un motor qué tan rápido debe girar. Un porcentaje más alto hace que el motor gire más rápido y un porcentaje más bajo hace que el motor gire más lento.

Cada proyecto comienza con cada motor girando al 50% de velocidad por defecto.

Nota: Una velocidad más alta hace que el motor gire más rápido, pero puede ser menos preciso. Una velocidad más baja hace que el motor gire más lento, pero puede ser más preciso.

Usage:
arm_motor.set_velocity(velocity)

Parámetros	Descripción
`velocity`	La velocidad para girar es de 0% a 100%. Esto puede ser un `integer` o decimal (`float`).

# Build Used: Competition Advanced 2.0
def main():
    # Move the ArmMotor at different velocities
    arm_motor.spin_for(REVERSE, 180, DEGREES)
    wait(1, SECONDS)
    # Move slow
    arm_motor.set_velocity(20)
    arm_motor.spin_for(FORWARD, 180, DEGREES)
    wait(1, SECONDS)
    # Move fast
    arm_motor.set_velocity(100)
    arm_motor.spin_for(REVERSE, 180, DEGREES)

# Start threads — Do not delete
start_thread(main)

set_max_torque #

El par es una fuerza de giro. Muestra la fuerza con la que un motor puede empujar o tirar cuando gira.

set_max_torque establece el par máximo que un motor puede usar.

Un porcentaje más alto permite que el motor empuje con más fuerza, como cuando se levanta un objeto pesado. Un porcentaje más bajo limita la fuerza con la que el motor puede empujar. Esto puede ayudar a proteger el robot si el motor se atasca o llega al final de lo lejos que puede moverse.

Cada proyecto comienza con el par de cada motor al 50% por defecto.

Usage:
arm_motor.set_max_torque(value)

Parámetros	Descripción
`value`	El par máximo que puede utilizar el motor es del 0% al 100%. Esto puede ser un `integer` o decimal (`float`).

# Build Used: Competition Advanced 2.0
def main():
    # Move the ArmMotor at different torques
    arm_motor.spin_for(REVERSE, 180, DEGREES)
    wait(1, SECONDS)
    # Move with less torque
    arm_motor.set_max_torque(20)
    arm_motor.spin_for(FORWARD, 180, DEGREES)
    wait(1, SECONDS)
    # Move with maximum torque
    arm_motor.set_max_torque(100)
    arm_motor.spin_for(REVERSE, 180, DEGREES)

# Start threads — Do not delete
start_thread(main)

set_position #

La posición de un motor es la distancia a la que ha girado, medida en DEGREES o TURNS. Un giro 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 a 180 grados, ajustar la posición a 0 grados restablecerá esa posición de 180 a 0 grados. Entonces el motor puede girar a posiciones basadas en ese nuevo valor.

Usage:
arm_motor.set_position(position, units)

Parámetros	Descripción
`position`	El valor de posición que se debe establecer para el motor. `DEGREES` usar números enteros. `TURNS` puede usar números enteros o decimales.
`units`	Opcional. La unidad de posición: `DEGREES` (predeterminado) o `TURNS`.

# Build Used: Competition Advanced 2.0
def main():
    # Return ArmMotor to 0 degrees after raising
    arm_motor.set_position(0, DEGREES)
    arm_motor.spin_for(REVERSE, 180, DEGREES)
    wait(1, SECONDS)
    arm_motor.spin_to_position(0, DEGREES)

# Start threads — Do not delete
start_thread(main)

set_stopping #

set_stopping establece cómo un motor dejará de moverse: frenando, deslizándose o reteniendo.

Usage:
arm_motor.set_stopping(mode)

Parámetros	Descripción
`mode`	Cómo se detendrá el motor: `BRAKE` — Se detiene inmediatamente. `COAST` — Se detiene lentamente. `HOLD` — Se detiene inmediatamente y mantiene la posición del motor.

Parámetros

Descripción

mode

Cómo se detendrá el motor:

BRAKE — Se detiene inmediatamente.
COAST — Se detiene lentamente.
HOLD — Se detiene inmediatamente y mantiene la posición del motor.

Por ejemplo, si se utiliza una compilación Competition Advanced 2.0 y arm_motor está configurado para HOLD, el motor mantendrá el brazo en su posición actual hasta que se produzca otro movimiento del brazo. Esto significa que el motor funcionará contra la gravedad para mantener el brazo en el aire si el motor se detuvo con el brazo levantado.

Si no se utiliza este método, el motor utilizará el BRAKE al detenerse.

# Build Used: Competition Advanced 2.0
def main():
    # Move the ArmMotor, then coast to a stop
    arm_motor.set_velocity(20)
    arm_motor.set_stopping(COAST)
    arm_motor.spin(REVERSE)
    wait(1, SECONDS)
    arm_motor.stop()

# Start threads — Do not delete
start_thread(main)

set_timeout #

set_timeout establece cuánto tiempo intentará un motor terminar 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 atasque en un movimiento.

Usage:
arm_motor.set_timeout(value, units)

Parámetros	Descripción
`value`	La cantidad de tiempo que el motor puede intentar terminar un movimiento. Esto puede ser un `integer` o decimal (`float`).
`units`	Opcional. La unidad de tiempo: `SECONDS` (predeterminado) o `MSEC` (milisegundos).

# Build Used: Competition Advanced 2.0
def main():
    # Move ArmMotor as far as possible for 1 second before resetting
    arm_motor.set_position(0, DEGREES)
    arm_motor.set_timeout(1, SECONDS)
    arm_motor.spin_for(REVERSE, 180, DEGREES)
    arm_motor.spin_to_position(0, DEGREES)

# Start threads — Do not delete
start_thread(main)

Getters #

get_position #

La posición de un motor es la distancia a la que ha girado, medida en DEGREES o TURNS. Un giro es igual a 360 grados. get_position devuelve la posición actual del motor.

Al comienzo de un proyecto, la posición del motor se establece en 0 grados. Si el motor gira un giro hacia adelante, la posición será de 360 grados o 1 giro. Si el motor gira en la otra dirección, la posición será negativa.

Usage:
arm_motor.get_position(units)

Parámetros	Descripción
`units`	Opcional. La unidad para devolver la posición del motor en: `DEGREES` (predeterminado) o `TURNS`.

# Build Used: Competition Advanced 2.0
def main():
    # Display how far the ArmMotor moves after one second
    arm_motor.set_position(0, DEGREES)
    console.print("Start: ")
    console.print(arm_motor.get_position(DEGREES))
    console.new_line()
    arm_motor.spin(REVERSE)
    wait(1, SECONDS)
    arm_motor.stop()
    console.print("After: ")
    console.print(arm_motor.get_position(DEGREES))

# Start threads — Do not delete
start_thread(main)

get_velocity #

get_velocity devuelve qué tan rápido está girando el motor, como un porcentaje de -100% a 100%.

Un valor positivo significa que el motor está girando hacia adelante. Un valor negativo significa que el motor está girando en reversa.

Usage:
arm_motor.get_velocity()

Parámetros	Descripción
	Este método no tiene parámetros.

# Build Used: Competition Advanced 2.0
def main():
    # Display the ArmMotor's velocity when it moves
    console.print("Resting: ")
    console.print(arm_motor.get_velocity())
    console.new_line()
    arm_motor.spin(REVERSE)
    wait(1, SECONDS)
    console.print("Moving: ")
    console.print(arm_motor.get_velocity())
    arm_motor.stop()

# Start threads — Do not delete
start_thread(main)

get_current #

get_current devuelve la cantidad de energía que el motor está utilizando de la batería, como un porcentaje de 0% a 100%.

Un valor de corriente más alto significa que el motor está utilizando más potencia. Esto puede suceder cuando el motor está levantando algo pesado, empujando contra un objeto o tratando de moverse cuando está atascado.

Usage:
arm_motor.get_current()

Parámetros	Descripción
	Este método no tiene parámetros.

# Build Used: Competition Advanced 2.0
def main():
    # Display the motor's current when it moves
    console.print("Resting: ")
    console.print(arm_motor.get_current())
    console.new_line()
    arm_motor.spin(REVERSE)
    wait(1, SECONDS)
    console.print("Moving: ")
    console.print(arm_motor.get_current())
    arm_motor.stop()

# Start threads — Do not delete
start_thread(main)

is_stopped #

is_stopped devuelve si el motor ha terminado de moverse, como un valor booleano. Esto se puede utilizar para controlar el tiempo de otros comportamientos basados en el movimiento del motor.

True : el motor ha terminado de moverse.
False : el motor todavía está 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.

Usage:
arm_motor.is_stopped()

Parámetros	Descripción
	Este método no tiene parámetros.

# Build Used: Competition Advanced 2.0
def main():
    # Turn the Eye Sensor's light on while ArmMotor is moving
    arm_motor.spin_for(REVERSE, 180, DEGREES, wait=False)
    wait(0.1, SECONDS)
    while True:
        if arm_motor.is_stopped():
            eye.set_light(OFF)
        else:
            eye.set_light(ON)

# Start threads — Do not delete
start_thread(main)

is_moving #

is_moving devuelve si el motor está girando, como un valor booleano. Esto se puede utilizar para controlar el tiempo de otros comportamientos basados en el 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.

Usage:
arm_motor.is_moving()

Parámetros	Descripción
	Este método no tiene parámetros.

# Build Used: Competition Advanced 2.0
def main():
    # Turn the Eye Sensor's light on while ArmMotor is moving
    arm_motor.spin_for(REVERSE, 180, DEGREES, wait=False)
    wait(0.1, SECONDS)
    while True:
        if arm_motor.is_moving():
            eye.set_light(ON)
        else:
            eye.set_light(OFF)

# Start threads — Do not delete
start_thread(main)