Transmissão#

Introdução #

O sistema de transmissão inclui rodas e motores que controlam a forma como o robô se move e gira. Os sistemas de transmissão podem ser encontrados em projetos como o Code Base 2.0, o Super Car ou um robô personalizado.

Os sistemas de transmissão utilizam o Sensor Inercial no Cérebro para detetar colisões e ajudar o robô a mover-se e a rodar com precisão. No início de cada projeto, o sistema de transmissão calibra o Sensor Inercial automaticamente. Mantenha o robô imóvel durante cerca de 2 segundos durante a calibração, para que se possa mover e rodar corretamente.

Existem muitas formas de programar o sistema de transmissão. Abaixo está uma lista de todos os métodos de programação do sistema de transmissão:

Ações — Mova e rode o robô.

drive — Move o robô para a frente ou para trás para sempre.
drive_for — Move o robô para a frente ou para trás uma distância específica.
drive_until — Move o robô para a frente até que o sensor ocular detete um objeto ou o robô detete uma colisão.
turn — Vira o robô para a esquerda ou para a direita para sempre.
turn_for — Roda o robô para a esquerda ou para a direita de um número específico de graus.
turn_to_heading — Roda o robô para enfrentar uma direção específica de -359 a 359 graus. O robô irá rodar na direção mais curta para alcançar a direção alvo.
turn_to_rotation — Roda o robô para uma rotação específica.
stop — Interrompe o movimento do robô.

Mutadores — Ajustam as definições da transmissão.

set_drive_velocity — Indica ao robô a velocidade de deslocação.
set_turn_velocity — Indica ao robô a velocidade a que deve virar.
set_stopping — Indica como o robô irá parar de se mover: travando, deslizando ou parando.
set_timeout — Define durante quanto tempo o robô tentará terminar um movimento.
set_heading — Altera a direção atual do robô para uma nova direção.
set_rotation — Altera a rotação atual do robô para uma nova rotação.

Receptores — Verifiquem o estado de movimentação.

get_heading — Retorna a direção atual do robô de 0 a 359 graus.
get_rotation — Retorna a rotação atual do robô.
get_velocity — Retorna a velocidade de deslocação do robô, em percentagem de -100% a 100%.
get_yaw — Retorna o yaw actual do robô.
get_roll — Retorna o scroll atual do robô.
get_pitch — Retorna o tom atual do robô.
get_crashed — Retorna se o robô detetou uma colisão, como por exemplo um valor booleano.
is_stopped — Retorna se o robô terminou de se mover, como um valor booleano.

Ações #

drive #

drive moves the robot forward or reverse forever. The robot will continue to move until it is given another action, like turning or stopping.

Usage:
drivetrain.drive(direction)

Parâmetros	Descrição
`direction`	A direção em que o robô se move: `FORWARD` ou `REVERSE`.

# Build Used: Code Base 2.0
def main():
    # Drive forward then stop
    drivetrain.drive(FORWARD)
    wait(2, SECONDS)
    drivetrain.stop()

# Start threads — Do not delete
start_thread(main)

drive_for #

O comando drive_for move o robô para a frente ou para trás por uma distância específica.

Usage:
drivetrain.drive_for(direction, distance, units, wait)

Parâmetros	Descrição
`direction`	A direção em que o robô se move: `FORWARD` ou `REVERSE`.
`distance`	A distância percorrida pelo robô. Pode ser um número inteiro ou decimal.
`units`	Opcional. A unidade de distância: `MM` (milímetros, standard) ou `INCHES`.
`wait`	Opcional. `wait=True` (padrão) faz com que o projeto aguarde até que o robô termine de se mover 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: Code Base 2.0
def main():
    # Drive back and forth
    drivetrain.drive_for(FORWARD, 100, MM)
    drivetrain.drive_for(REVERSE, 4, INCHES)
    

# Start threads — Do not delete
start_thread(main)

drive_until #

drive_until move o robô para a frente até que o sensor ocular detete um objeto ou o robô detete uma colisão.

Usage:
drivetrain.drive_until(condition, wait)

Parâmetros	Descrição
`condition`	A condição que para o robô: `OBJECT` ou `CRASH`.
`wait`	Opcional. `wait=True` (padrão) faz com que o projeto aguarde até que o robô termine de se mover 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: Code Base 2.0
def main():
    # Turn right after a crash
    drivetrain.drive_until(CRASH)
    drivetrain.turn_for(RIGHT, 90)

# Start threads — Do not delete
start_thread(main)

turn #

O comando turn o robô vire para a esquerda ou para a direita indefinidamente. O robô continuará a virar até receber outra ação, como conduzir ou parar.

Usage:
drivetrain.turn(direction)

Parâmetros	Descrição
`direction`	Direção para a qual o robô vira: `LEFT` ou `RIGHT`.

# Build Used: Code Base 2.0
def main():
    # Turn right and left, then stop
    drivetrain.turn(RIGHT)
    wait(2, SECONDS)
    drivetrain.turn(LEFT)
    wait(2, SECONDS)
    drivetrain.stop()

# Start threads — Do not delete
start_thread(main)

turn_for #

O comando turn_for roda o robô para a esquerda ou para a direita num número específico de graus. A rotação é relativa à posição atual do robô.

Usage:
drivetrain.turn_for(direction, angle, wait)

Parâmetros	Descrição
`direction`	Direção para a qual o robô vira: `LEFT` ou `RIGHT`.
`angle`	O número de graus que o robô roda. Pode ser um número inteiro ou decimal.
`wait`	Opcional. `wait=True` (padrão) faz com que o projeto aguarde até que o robô 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: Code Base 2.0
def main():
    # Turn right then left
    drivetrain.turn_for(RIGHT, 90)
    drivetrain.turn_for(LEFT, 90)

# Start threads — Do not delete
start_thread(main)

turn_to_heading #

A direção é a direção para a qual o cérebro do robô está a apontar, medida em graus. turn_to_heading roda o robô para apontar para uma direção específica de -359 a 359 graus. O robô irá rodar na direção mais curta para alcançar a direção desejada.

A direção inicial é de 0 graus.

Uma base de código VEX GO 2.0 mostrando as direcções de rumo: 0 graus para a frente, 90 graus para a direita, 180 graus para trás e 270 graus para a esquerda.

Usage:
drivetrain.turn_to_heading(angle, wait)

Parâmetros	Descrição
`angle`	A direção para a qual o robô deve estar virado, expressa como um número inteiro, de -359 a 359 graus.
`wait`	Opcional. `wait=True` (padrão) faz com que o projeto aguarde até que o robô 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: Code Base 2.0
def main():
    # Turn to face the cardinal directions
    drivetrain.turn_to_heading(90)
    wait(1, SECONDS)
    drivetrain.turn_to_heading(180)
    wait(1, SECONDS)
    drivetrain.turn_to_heading(270)
    wait(1, SECONDS)
    drivetrain.turn_to_heading(0)

# Start threads — Do not delete
start_thread(main)

turn_to_rotation #

turn_to_rotation roda o robô para uma rotação específica.

A rotação é o quanto o robô rodou, medida em graus. No início de um projeto, o valor de rotação é definido como 0 graus. A rotação também pode ser definida utilizando set_rotation.

Os valores de rotação são absolutos. Isto significa que a direção da viragem depende da rotação atual do robô. Virar para a direita aumenta a rotação, e virar para a esquerda diminui a rotação.

Por exemplo, se o robô começar a 0 graus e rodar 720 graus, este irá virar para a direita duas vezes. Se depois rodar 360 graus, virará para a esquerda uma vez, porque 360 é inferior a 720.

Uma base de código VEX GO 2.0 que mostra setas a rodar para a direita e para a esquerda. A seta da esquerda mostra "menos" e a seta da direita mostra "mais".

Usage:
drivetrain.turn_to_rotation(angle, wait)

Parâmetros	Descrição
`angle`	O valor de rotação, em graus, para o qual o robô irá rodar. Pode ser um número inteiro.
`wait`	Opcional. `wait=True` (padrão) faz com que o projeto aguarde até que o robô 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: Code Base 2.0
def main():
    # Make one full turn to the right
    drivetrain.turn_to_rotation(360)
    # Make another full turn to the right
    drivetrain.turn_to_rotation(720)
    # Make one full turn to the left, returning to 360 degrees
    drivetrain.turn_to_rotation(360)
# Start threads — Do not delete
start_thread(main)

stop #

stop pára o movimento do robô.

Usage:
drivetrain.stop()

Parâmetros	Descrição
	Este método não tem parâmetros.

# Build Used: Code Base 2.0
def main():
    # Drive forward then stop
    drivetrain.drive(FORWARD)
    wait(2, SECONDS)
    drivetrain.stop()

# Start threads — Do not delete
start_thread(main)

Mutantes #

set_drive_velocity #

O parâmetro set_drive_velocity ( set_drive_velocity define a velocidade de deslocação do robô. Uma percentagem mais elevada faz com que o robô se desloque mais rapidamente, enquanto uma percentagem mais baixa o faz deslocar-se mais lentamente.

Todos os projetos começam com o robô a deslocar-se a 50% da velocidade por defeito.

Nota: Uma velocidade mais elevada faz com que o robô se mova mais rapidamente, mas pode ser menos preciso. Uma velocidade mais baixa faz com que o robô se mova mais devagar, mas seja mais preciso.

Usage:
drivetrain.set_drive_velocity(velocity)

Parâmetros	Descrição
`velocity`	A velocidade de condução varia entre 0% a 100%.

# Build Used: Code Base 2.0
def main():
    # Drive at different velocities
    drivetrain.drive_for(FORWARD, 100, MM)
    wait(1, SECONDS)
    # Drive slow
    drivetrain.set_drive_velocity(20)
    drivetrain.drive_for(FORWARD, 100, MM)
    wait(1, SECONDS)
    # Drive fast
    drivetrain.set_drive_velocity(100)
    drivetrain.drive_for(FORWARD, 100, MM)

# Start threads — Do not delete
start_thread(main)

set_turn_velocity #

O parâmetro set_turn_velocity define a velocidade de rotação do robô. Uma percentagem mais elevada faz com que o robô gire mais rápido, enquanto uma percentagem mais baixa faz com que o robô gire mais devagar.

Todos os projetos começam com o robô a rodar a 50% da velocidade por defeito.

Nota: Uma velocidade mais elevada faz com que o robô gire mais rápido, mas pode ser menos preciso. Uma velocidade mais baixa faz com que o robô gire mais devagar, mas seja mais preciso.

Usage:
drivetrain.set_turn_velocity(velocity)

Parâmetros	Descrição
`velocity`	A velocidade de rotação varia entre 0% a 100%.

# Build Used: Code Base 2.0
def main():
    # Turn at different velocities
    drivetrain.turn_for(RIGHT, 180)
    wait(1, SECONDS)
    # Turn fast
    drivetrain.set_turn_velocity(100)
    drivetrain.turn_for(RIGHT, 180)

# Start threads — Do not delete
start_thread(main)

set_stopping #

set_stopping define a forma como o robô irá parar de se mover: travando, deslizando ou parando.

Usage:
drivetrain.set_stopping(brake)

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

Parâmetros

Descrição

brake

Como o robot irá parar:

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

Caso este método não seja utilizado, o robô utilizará BRAKE ao parar.

# Build Used: Code Base 2.0
def main():
    # Drive, then coast to a stop
    drivetrain.set_drive_velocity(100)
    drivetrain.set_stopping(COAST)
    drivetrain.drive(FORWARD)
    wait(2, SECONDS)
    drivetrain.stop()

# Start threads — Do not delete
start_thread(main)

set_timeout #

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

Usage:
drivetrain.set_timeout(value, units)

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

# Build Used: Code Base 2.0
def main():
    # Drive as far as possible for 1 second before turning right
    drivetrain.set_timeout(1, SECONDS)
    drivetrain.drive_for(FORWARD, 25, INCHES)
    drivetrain.turn_for(RIGHT, 90)

# Start threads — Do not delete
start_thread(main)

set_heading #

A direção é a direção para a qual o cérebro do robô está a apontar, medida em graus. set_heading altera a direção atual do robô para um novo valor de direção.

Por exemplo, se o robô se virou para a direita, definir a direção para 0 graus faz com que essa posição virada para a direita se torne os novos 0 graus. De seguida, o robô pode rodar para outras posições com base nessa nova direção.

Usage:
drivetrain.set_heading(value)

Parâmetros	Descrição
`value`	O valor da direção, em graus, a definir para o robô. Pode ser um número inteiro de 0 a 359.

# Build Used: Code Base 2.0
def main():
    # Face the new 0 degree heading
    drivetrain.set_heading(90)
    drivetrain.turn_to_heading(0)

# Start threads — Do not delete
start_thread(main)

set_rotation #

A rotação indica o quanto o robô rodou, medida em graus. No início de um projeto, o valor de rotação é definido como 0 graus. O comando set_rotation altera a rotação actual do robô para um novo valor.

Por exemplo, se o robô tiver dado duas voltas completas para a direita, o seu valor de rotação será de 720 graus. Definir a rotação para 0 graus irá repor essa rotação de 720 para 0 graus. De seguida, o robô poderá rodar para rotações baseadas nesse novo valor.

Usage:
drivetrain.set_rotation(value)

Parâmetros	Descrição
`value`	O valor de rotação, em graus, a definir para o robô. Pode ser um número inteiro.

# Build Used: Code Base 2.0
def main():
    # Spin counterclockwise two times
    drivetrain.set_rotation(720)
    drivetrain.turn_to_rotation(0)

# Start threads — Do not delete
start_thread(main)

Getters #

get_heading #

A direção (heading) é a direção para a qual o cérebro do robô está a apontar, medida em graus. get_heading devolve esta direcção, variando de 0 a 359 graus.

A direção inicial do robô é de 0 graus.

Um VEX GO Brain mostrando as direcções de rumo: 0 graus para a frente, 90 graus para a direita, 180 graus para trás e 270 graus para a esquerda.

Usage:
drivetrain.get_heading()

Parâmetros	Descrição
	Este método não tem parâmetros.

# Build Used: Code Base 2.0
def main():
    # Display the heading while turning
    monitor_sensor("drivetrain.get_heading")
    drivetrain.turn_for(RIGHT, 450)


# Start threads — Do not delete
start_thread(main)

get_rotation #

A rotação indica o quanto o robô rodou, medida em graus. No início de um projeto, o valor de rotação é definido como 0 graus. get_rotation devolve a rotação actual do robô.

Virar para a direita aumenta a rotação, e virar para a esquerda diminui a rotação. Por exemplo, duas voltas completas para a direita resultarão numa rotação de 720 graus.

Uma base de código VEX GO 2.0 que mostra setas a rodar para a direita e para a esquerda. A seta da esquerda mostra "menos" e a seta da direita mostra "mais".

Usage:
drivetrain.get_rotation()

Parâmetros	Descrição
	Este método não tem parâmetros.

# Build Used: Code Base 2.0
def main():
    # Display the rotation while turning
    monitor_sensor("drivetrain.get_rotation")
    drivetrain.turn_for(RIGHT, 450)


# Start threads — Do not delete
start_thread(main)

get_velocity #

get_velocity devolve a velocidade de deslocamento do robô, em percentagem, de -100% a 100%.

Um valor positivo significa que o robô se está a mover para a frente. Um valor negativo significa que o robô se está a mover para trás.

Usage:
drivetrain.get_velocity()

Parâmetros	Descrição
	Este método não tem parâmetros.

# Build Used: Code Base 2.0
def main():
    # Display the velocity of the robot before and while moving
    console.print("Start: ")
    console.print(drivetrain.get_velocity())
    console.new_line()
    drivetrain.drive(FORWARD)
    wait(0.5, SECONDS)
    console.print("Moving: ")
    console.print(drivetrain.get_velocity())
    drivetrain.stop()


# Start threads — Do not delete
start_thread(main)

get_yaw #

O yaw indica o quanto o robô rodou para a esquerda ou para a direita a partir da sua posição inicial, medido em graus. get_yaw get_yaw devolve o valor actual.

Virar para a direita aumenta o valor de guinada, e virar para a esquerda diminui o valor de guinada.

Usage:
drivetrain.get_yaw()

Parâmetros	Descrição
	Este método não tem parâmetros.

# Build Used: Super Code Base 2.0
def main():
    # Change the LED color based on the yaw while
    # moving the robot by hand
    monitor_sensor("drivetrain.get_yaw")
    while True:
        if drivetrain.get_yaw() > 0:
            bumper.set_color(GREEN)
        elif drivetrain.get_yaw() < 0:
            bumper.set_color(RED)
        else:
            bumper.set_color(NONE)

# Start threads — Do not delete
start_thread(main)

get_roll #

A inclinação (roll) indica o quanto o robô se inclina para a esquerda ou para a direita, medida em graus. get_roll devolve o valor actual da inclinação (roll) do robô.

Com o cérebro virado para a frente, inclinar para a esquerda aumenta o valor da rotação, e inclinar para a direita diminui o valor da rotação.

Usage:
drivetrain.get_roll()

Parâmetros	Descrição
	Este método não tem parâmetros.

# Build Used: Super Code Base 2.0
def main():
    # Change the LED color based on the roll while
    # moving the robot by hand
    monitor_sensor("drivetrain.get_roll")
    while True:
        if drivetrain.get_roll() > 0:
            bumper.set_color(GREEN)
        elif drivetrain.get_roll() < 0:
            bumper.set_color(RED)
        else:
            bumper.set_color(NONE)

# Start threads — Do not delete
start_thread(main)

get_pitch #

O parâmetro pitch indica o quanto o robô se inclina para a frente ou para trás, medido em graus. get_pitch get_pitch devolve o valor actual do pitch do robô.

Com o cérebro virado para a frente, inclinar-se para a frente aumenta o valor do tom, e inclinar-se para trás diminui o valor do tom.

Usage:
drivetrain.get_pitch()

Parâmetros	Descrição
	Este método não tem parâmetros.

# Build Used: Super Code Base 2.0
def main():
    # Change the LED color based on the pitch while
    # moving the robot by hand
    monitor_sensor("drivetrain.get_pitch")
    while True:
        if drivetrain.get_pitch() > 0:
            bumper.set_color(GREEN)
        elif drivetrain.get_pitch() < 0:
            bumper.set_color(RED)
        else:
            bumper.set_color(NONE)

# Start threads — Do not delete
start_thread(main)

get_crashed #

get_crashed retorna se o robô detetou uma colisão, como por exemplo um valor booleano.

True — Foi detectada uma avaria.
False — Não foi detectada qualquer falha.

Usage:
drivetrain.get_crashed()

Parâmetros	Descrição
	Este método não tem parâmetros.

# Build Used: Super Code Base 2.0
def main():
    # Drive until a crash
    drivetrain.drive(FORWARD)
    while not drivetrain.get_crashed():
        wait(50, MSEC)
    drivetrain.stop()
    drivetrain.turn_for(RIGHT, 90)

# Start threads — Do not delete
start_thread(main)

is_stopped #

O valor is_stopped is_stopped` devolve um valor booleano indicando se o robô terminou de se mover. Isto pode ser utilizado para controlar o tempo de outras ações com base no movimento do robô.

True — O robô terminou de se mover.
False — O robô ainda se está a mover.

Este método funciona em conjunto com os seguintes métodos de transmissão que têm o parâmetro wait : drive_for, drive_until, turn_for, turn_to_heading, e turn_to_rotation.

Usage:
drivetrain.is_stopped()

Parâmetros	Descrição
	Este método não tem parâmetros.

# Build Used: Code Base 2.0
def main():
    # Turn when the drivetrain is done moving forward
    drivetrain.drive_for(FORWARD, 100, MM, wait=False)
    wait(0.25, SECONDS)
    while True:
        if drivetrain.is_stopped():
            drivetrain.turn_for(RIGHT, 180)
            break
        else:
            console.print("Still moving...")
            wait(0.1, SECONDS)
            console.clear()

# Start threads — Do not delete
start_thread(main)