Movimento#

Introdução #

Os motores controlam a forma como as partes de um robô se movem. Os motores podem ser utilizados para levantar um braço, rodar uma garra, rodar uma roda ou mover outra parte de uma construção. Dois motores podem trabalhar em conjunto como um trem de força para mover e rodar todo o robô.

Cada motor é configurado na janela Dispositivos. Dependendo da versão, os nomes dos motores podem sofrer alterações. Por exemplo, a versão Competition Advanced 2.0 tem um motor chamado arm_motorUm robô personalizado pode utilizar nomes de motores diferentes.

Por predefinição, FORWARD roda um motor no sentido anti-horário e REVERSE roda um motor no sentido horário. Se um motor estiver configurado para inverter a rotação na janela Dispositivos, estes sentidos serão trocados.

Um motor VEX GO que mostra o sentido de rotação para a frente, indicado por um sinal de mais e uma seta que indica que está a rodar para a esquerda, ou no sentido anti-horário.

Um motor VEX GO que mostra o sentido inverso indicado por um sinal de menos e uma seta que indica que está a rodar para a direita, ou no sentido dos ponteiros do relógio.

Existem muitas formas de programar motores. Abaixo está uma lista de todos os métodos de movimento:

Ações — Parar e rodar os motores.

spin — Roda um motor para a frente ou para trás para sempre.
spin_for — Roda um motor a uma distância específica.
spin_to_position — Roda um motor para uma posição específica.
stop — Impede que um motor gire.

Mudadores — Ajustam as definições do motor.

set_velocity — Diz a um motor a que velocidade deve rodar.
set_max_torque — Define a força máxima que um motor pode exercer enquanto roda.
set_position — Altera a posição actual do motor para um novo valor.
set_stopping — Define a forma como um motor irá parar de se mover: por travagem, inércia ou paragem.
set_timeout — Define durante quanto tempo um motor tentará terminar um movimento.

Getters — Verificar o estado do motor.

get_position — Retorna a posição actual do motor.
get_velocity — Devolve a velocidade de rotação do motor, em percentagem de -100% a 100%.
get_current — Retorna a quantidade de energia que o motor está a utilizar da bateria, em percentagem de 0% a 100%.
is_stopped — Retorna se o motor terminou de se mover, como um valor booleano.
is_moving — Retorna se o motor está a rodar, como um valor booleano.

Ações #

spin #

O comando spin faz com que o motor gire para a frente ou para trás indefinidamente. O motor continuará a rodar até receber outra ação, como rodar numa direção diferente ou parar.

Usage:
arm_motor.spin(direction)

Parâmetros	Descrição
`direction`	Sentido de rotação do motor: `FORWARD` ou `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 #

O comando spin_for faz rodar um motor por uma distância específica. A rotação é relativa à posição atual do motor. O projeto aguardará até que o motor termine de rodar antes de executar a próxima linha de código.

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

Parâmetros	Descrição
`direction`	Sentido de rotação do motor: `FORWARD` ou `REVERSE`.
`angle`	A distância a que o motor roda. `DEGREES` utilize números inteiros. `TURNS` pode utilizar números inteiros ou decimais.
`units`	Opcional. A unidade de distância: `DEGREES` (padrão) ou `TURNS`.
`wait`	Opcional. `wait=True` (padrão) faz com que o projeto aguarde até que o motor termine de rodar antes de executar a próxima linha de código. `wait=False` faz com que a próxima linha de código seja executada imediatamente.

# 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 roda um motor para uma posição específica.

A posição de um motor é o quanto ele rodou, medido em DEGREES ou TURNSUma volta é igual a 360 graus. No início de um projeto, a posição do motor é definida para 0 graus. A posição do motor também pode ser definida através do método set_position.

Os valores de posição são absolutos. Isto significa que o sentido de rotação depende da posição atual do motor.

Por exemplo, se o motor arrancar a 0 graus e rodar até uma posição de 720 graus, dará duas voltas para a frente. Se depois rodar até uma posição de 360 graus, dará uma volta para trás, porque 360 é inferior a 720.

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

Parâmetros	Descrição
`angle`	O valor da posição para a qual o motor irá rodar. `DEGREES` utilize números inteiros. `TURNS` pode utilizar números inteiros ou decimais.
`units`	Opcional. A unidade de posição: `DEGREES` (padrão) ou `TURNS`.
`wait`	Opcional. `wait=True` (padrão) faz com que o projeto aguarde até que o motor termine de rodar antes de executar a próxima linha de código. `wait=False` faz com que a próxima linha de código seja executada imediatamente.

# 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 impede que um motor gire.

Usage:
arm_motor.stop()

Parâmetros	Descrição
	Este método não tem 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)

Mutantes #

set_velocity #

O parâmetro set_velocity define a velocidade de rotação do motor. Uma percentagem mais elevada faz com que o motor gire mais depressa, enquanto uma percentagem mais baixa faz com que o motor gire mais devagar.

Cada projeto começa com cada motor a rodar a 50% da velocidade por defeito.

Nota: Uma velocidade mais elevada faz com que o motor gire mais depressa, mas pode ser menos precisa. Uma velocidade mais baixa faz com que o motor gire mais devagar, mas pode ser mais preciso.

Usage:
arm_motor.set_velocity(velocity)

Parâmetros	Descrição
`velocity`	A velocidade de rotação, de 0% a 100%. Pode ser um número inteiro `integer` ou um número de ponto flutuante (`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 #

O binário é uma força de rotação. Indica a força que um motor pode exercer ao rodar, seja empurrando ou puxando.

set_max_torque define o binário máximo que um motor pode utilizar.

Uma percentagem mais elevada permite que o motor empurre com mais força, como quando levanta um objeto pesado. Uma percentagem mais baixa limita a força que o motor pode exercer. Isto pode ajudar a proteger o robô caso o motor bloqueie ou atinja o limite da sua capacidade de movimento.

Todos os projetos começam com o binário de cada motor a 50% por defeito.

Usage:
arm_motor.set_max_torque(value)

Parâmetros	Descrição
`value`	O binário máximo que o motor pode utilizar, de 0% a 100%. Pode ser um número inteiro `integer` ou 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 #

A posição de um motor é o quanto ele rodou, medida em DEGREES ou TURNSUma volta é igual a 360 graus. set_position altera a posição atual do motor para um novo valor.

Por exemplo, se um motor tiver rodado 180 graus, definir a posição para 0 graus irá repor essa posição de 180 para 0 graus. De seguida, o motor poderá rodar para posições baseadas nesse novo valor.

Usage:
arm_motor.set_position(position, units)

Parâmetros	Descrição
`position`	O valor de posição a definir para o motor. `DEGREES` utilize números inteiros. `TURNS` pode utilizar números inteiros ou decimais.
`units`	Opcional. A unidade de posição: `DEGREES` (padrão) ou `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 define a forma como um motor irá parar de se mover: por travagem, inércia ou paragem.

Usage:
arm_motor.set_stopping(mode)

Parâmetros	Descrição
`mode`	Como o motor irá parar: `BRAKE` — Pára imediatamente. `COAST` — Diminui a velocidade até parar. `HOLD` — Pára imediatamente e mantém a posição do motor.

Parâmetros

Descrição

mode

Como o motor irá parar:

BRAKE — Pára imediatamente.
COAST — Diminui a velocidade até parar.
HOLD — Pára imediatamente e mantém a posição do motor.

Por exemplo, se for utilizada uma configuração Competition Advanced 2.0 e o comando arm_motor estiver definido para HOLD, o motor manterá o braço na posição actual até que ocorra outro movimento. Isto significa que o motor trabalhará contra a gravidade para manter o braço no ar, caso tenha sido parado com o braço levantado.

Se este método não for utilizado, o motor utilizará BRAKE ao parar.

# 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 #

O parâmetro set_timeout define durante quanto tempo um motor tentará completar um movimento. Se o motor não conseguir completar o movimento durante esse tempo, interromperá a tentativa e passará para a linha de código seguinte. Isto evita que o motor fique preso num movimento.

Usage:
arm_motor.set_timeout(value, units)

Parâmetros	Descrição
`value`	O tempo que o motor pode tentar para completar um movimento. Pode ser um número inteiro positivo `integer` ou decimal (`float`).
`units`	Opcional. A unidade de tempo: `SECONDS` (padrão) ou `MSEC` (milissegundos).

# 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 #

A posição de um motor é o quanto ele rodou, medido em DEGREES ou TURNSUma volta é igual a 360 graus. get_position retorna a posição atual do motor.

No início de um projeto, a posição do motor é definida para 0 graus. Se o motor rodar uma volta para a frente, a posição será de 360 graus ou 1 volta. Se o motor rodar no sentido oposto, a posição será negativa.

Usage:
arm_motor.get_position(units)

Parâmetros	Descrição
`units`	Opcional. A unidade para voltar à posição do motor em: `DEGREES` (padrão) ou `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 devolve a velocidade de rotação do motor, em percentagem, de -100% a 100%.

Um valor positivo significa que o motor está a rodar para a frente. Um valor negativo significa que o motor está a rodar para trás.

Usage:
arm_motor.get_velocity()

Parâmetros	Descrição
	Este método não tem 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 devolve a quantidade de energia que o motor está a utilizar da bateria, em percentagem de 0% a 100%.

Um valor de corrente mais elevado significa que o motor está a consumir mais energia. Isto pode acontecer quando o motor está a levantar algo pesado, a empurrar um objeto ou a tentar mover-se quando está bloqueado.

Usage:
arm_motor.get_current()

Parâmetros	Descrição
	Este método não tem 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 devolve um valor booleano indicando se o motor terminou de se mover. Isto pode ser utilizado para controlar o tempo de outras ações com base no movimento do motor.

True — O motor terminou de se mover.
False — O motor ainda está em movimento.

Este método funciona em conjunto com os seguintes métodos de movimento que têm o parâmetro wait : spin_for e spin_to_position.

Usage:
arm_motor.is_stopped()

Parâmetros	Descrição
	Este método não tem 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 retorna se o motor está a rodar, como um valor booleano. Isto pode ser utilizado para controlar o tempo de outros comportamentos com base no movimento do motor.

True — O motor está a rodar.
False — O motor não está a rodar.

Este método funciona em conjunto com os seguintes métodos de movimento que têm o parâmetro wait : spin_for e spin_to_position.

Usage:
arm_motor.is_moving()

Parâmetros	Descrição
	Este método não tem 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)