Python específico para robôs#

Introdução #

O robô herói Disco inclui um conjunto de motores, um seguidor de linha, um sensor ótico e um sensor de sistema de posicionamento de jogo (GPS).

Todos os métodos VR padrão do VEXcode estão disponíveis para utilização no V5 22-23 Spin Up Playground.

Abaixo segue uma lista de todos os métodos disponíveis específicos para robôs:

Sistema de transmissão – Movimenta e roda o robô.

Ações
- 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.
- 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.
- turn_to_rotation — Roda o robô para uma rotação específica.
- stop — Interrompe o movimento do robô.
Mutadores
- 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.
- set_timeout — Define durante quanto tempo o robô tentará terminar um movimento.
- set_drive_velocity — Indica ao robô a velocidade de deslocação.
- set_turn_velocity — Indica ao robô a velocidade a que deve virar.
Obteve
- heading — Devolve a direção atual do robô de 0 a 359,99 graus.
- rotation — Retorna a rotação atual do robô.
- is_done — Retorna se o robô terminou de se mover, como um valor booleano.
- is_moving — Retorna se o robô se está a mover, como um valor booleano.
- velocity — Devolve a velocidade de deslocação do robô.

Movimento – Movimente e acompanhe o grupo de motores do robô.

Ações
- spin — Roda um grupo de motores para a frente ou para trás para sempre.
- spin_for — Roda um grupo de motores a uma distância específica.
- spin_to_position — Roda um grupo de motores para uma posição específica.
- stop — Impede que um grupo de motores gire.
Mutadores
- set_position — Altera a posição actual do grupo de motores para um novo valor.
- set_velocity — Indica a um grupo de motores a velocidade de rotação.
- set_timeout — Define durante quanto tempo um grupo de motores tentará terminar um movimento.
Obteve
- is_done — Retorna se o grupo de motores terminou de se mover, como um valor booleano.
- is_spinning — Retorna se o grupo de motores está a rodar, como um valor booleano.
- position — Retorna a posição actual do grupo de motores.
- velocity — Devolve a velocidade de rotação do grupo de motores.

Consola – Imprima na consola e monitorize os valores.

Imprimir
- brain.screen.print — Apresenta texto, números ou valores de variáveis na Consola.
- brain.screen.next_row — Move o cursor da Consola para o início da linha seguinte.
- brain.screen.clear_screen — Limpa todas as linhas da Consola.
Monitor
- monitor_variable — Adiciona uma ou mais variáveis predefinidas ao separador Monitor.
- monitor_sensor — Adiciona um ou mais valores de sensor ao separador Monitor.

Deteção - Utilize os vários sensores do robô.

Óptico
- is_near_object – Retorna se o sensor ótico deteta um objeto dentro do alcance.
- color – Devolve a cor detectada pelo sensor óptico.
- brightness – Devolve a quantidade de luz reflectida pelo objecto.
- hue – Devolve a matiz detectada pelo sensor óptico.
- object_detected – Regista uma função a chamar quando o Sensor Óptico detecta um objecto.
- object_lost – Regista uma função a ser chamada quando o Sensor Óptico perde um objecto.
GPS
- x_position – Retorna a coordenada x actual de um sensor GPS no campo.
- y_position – Retorna a coordenada y actual de um sensor GPS no campo.
- heading – Retorna a direção para a qual o robô está atualmente virado com base nas leituras do sensor GPS de 0 a 359 graus.
Rastreador de filas
- reflectivity – Devolve a quantidade de luz reflectida pela superfície.

Os exemplos nesta página utilizam a posição inicial padrão do Playground.

O sistema de transmissão controla a forma como o robô de realidade virtual se move e gira. Pode mover-se para a frente ou para trás, virar para a esquerda ou para a direita, mudar de direção e acompanhar a sua rotação.

Ações #

conduzir #

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`.

def main():
    # Drive forward then stop
    drivetrain.drive(FORWARD)
    wait(2, SECONDS)
    drivetrain.stop()

# VR threads — Do not delete
vr_thread(main)

conduzir_para #

O comando drive_for move o robô para a frente ou para trás por uma distância específica. O projeto aguardará até que o robô termine de se mover antes de executar a próxima linha de código.

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 `integer` ou decimal (`float`).
`units`	Opcional. A unidade de distância: `INCHES` (padrão) ou `MM` (milímetros).
`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.

def main():
    # Drive forward and backward
    drivetrain.drive_for(FORWARD, 200, MM)
    drivetrain.drive_for(REVERSE, 200, MM)

# VR threads — Do not delete
vr_thread(main)

virar #

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`.

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

# VR threads — Do not delete
vr_thread(main)

virar_para #

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ô. O projeto aguardará até que o robô termine de rodar antes de executar a próxima linha de código.

Usage:
drivetrain.turn_for(direction, angle, units, 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 `integer` ou decimal (`float`).
`units`	Opcional. Unidade de rotação: `DEGREES` (padrão).
`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.

def main():
    # Turn the robot right and left
    drivetrain.turn_for(RIGHT, 90, DEGREES)
    wait(1, SECONDS)
    drivetrain.turn_for(LEFT, 90, DEGREES)

# VR threads — Do not delete
vr_thread(main)

virar_para_o_título #

A direção é a direção para a qual o robô está virado, medida em graus. turn_to_heading roda o robô de modo a ficar virado 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 do robô é de 0 graus.

O projeto aguardará até que o robô termine de rodar antes de executar a próxima linha de código.

Usage:
drivetrain.turn_to_heading(angle, units, wait)

Parâmetros	Descrição
`angle`	A direção para a qual o robô deve estar virado, em graus. Pode ser um número inteiro `integer` ou um número de ponto flutuante (`float`), de -359 a 359.
`units`	Opcional. Unidade de rotação: `DEGREES` (padrão).
`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.

def main():
    # Turn to face the cardinal directions
    drivetrain.turn_to_heading(90, DEGREES)
    wait(1, SECONDS)
    drivetrain.turn_to_heading(180, DEGREES)
    wait(1, SECONDS)
    drivetrain.turn_to_heading(270, DEGREES)
    wait(1, SECONDS)
    drivetrain.turn_to_heading(0, DEGREES)

# VR threads — Do not delete
vr_thread(main)

rodar_para_rotação #

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 através do método 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.

O projeto aguardará até que o robô termine de rodar antes de executar a próxima linha de código.

Usage:
drivetrain.turn_to_rotation(angle, units, 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 `integer` ou decimal (`float`).
`units`	Opcional. Unidade de rotação: `DEGREES` (padrão).
`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.

def main():
    # Turn left, then spin in a circle
    # clockwise and face right
    drivetrain.turn_to_rotation(-90, DEGREES)
    wait(1, SECONDS)
    drivetrain.turn_to_rotation(450, DEGREES)

# VR threads — Do not delete
vr_thread(main)

parar #

stop interrompe o movimento do robô.

Usage:
drivetrain.stop()

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

def main():
    # Drive forward then stop
    drivetrain.drive(FORWARD)
    wait(2, SECONDS)
    drivetrain.stop()

# VR threads — Do not delete
vr_thread(main)

Mutantes #

definir_cabeçalho #

A direção é a direção para a qual o robô está virado, 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(heading, units)

Parâmetros	Descrição
`heading`	O valor de direção, em graus, a definir para o robô. Pode ser um número inteiro `integer` ou decimal (`float`).
`units`	Opcional. Unidade de medida do cabeçalho: `DEGREES` (padrão).

def main():
    # Face the new 0 degrees
    drivetrain.set_heading(90, DEGREES)
    drivetrain.turn_to_heading(0, DEGREES)

# VR threads — Do not delete
vr_thread(main)

definir_rotação #

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(rotation, units)

Parâmetros	Descrição
`rotation`	O valor de rotação, em graus, a definir para o robô. Pode ser um número inteiro `integer` ou decimal (`float`).
`units`	Opcional. Unidade de rotação: `DEGREES` (padrão).

def main():
    # Spin counterclockwise two times
    drivetrain.set_rotation(720, DEGREES)
    drivetrain.turn_to_rotation(0, DEGREES)

# VR threads — Do not delete
vr_thread(main)

definir_tempo limite #

O parâmetro 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 positivo `integer` ou decimal (`float`).
`units`	A unidade de tempo: `SECONDS` ou `MSEC` (milissegundos).

def main():
    # Turn right after driving forward
    drivetrain.set_timeout(1, SECONDS)
    drivetrain.drive_for(FORWARD, 25, INCHES)
    drivetrain.turn_for(RIGHT, 90)

# VR threads — Do not delete
vr_thread(main)

definir_velocidade_de_acionamento #

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 pode ser mais preciso.

Usage:
drivetrain.set_drive_velocity(velocity, units)

Parâmetros	Descrição
`velocity`	A velocidade de condução, de 0% a 100%. Pode ser um número inteiro `integer` ou decimal (`float`).
`units`	Opcional. Unidade de velocidade: `PERCENT` (padrão).

def main():
    # Drive forward at different velocities
    # Default velocity
    drivetrain.drive_for(FORWARD, 150, MM)
    wait(1, SECONDS)
    # Drive slower
    drivetrain.set_drive_velocity(20, PERCENT)
    drivetrain.drive_for(FORWARD, 150, MM)
    wait(1, SECONDS)
    # Drive faster
    drivetrain.set_drive_velocity(100, PERCENT)
    drivetrain.drive_for(FORWARD, 150, MM)

# VR threads — Do not delete
vr_thread(main)

definir_velocidade_de_viragem #

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 o faz girar 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 pode ser mais preciso.

Usage:
drivetrain.set_turn_velocity(velocity, units)

Parâmetros	Descrição
`velocity`	A velocidade de rotação, de 0% a 100%. Pode ser um número inteiro `integer` ou decimal (`float`).
`units`	Opcional. Unidade de velocidade: `PERCENT` (padrão).

def main():
    # Turn at different velocities
    # Default velocity
    drivetrain.turn_for(RIGHT, 120, DEGREES)
    wait(1, SECONDS)
    # Turn slower
    drivetrain.set_turn_velocity(20, PERCENT)
    drivetrain.turn_for(RIGHT, 120, DEGREES)
    wait(1, SECONDS)
    # Turn faster
    drivetrain.set_turn_velocity(100, PERCENT)
    drivetrain.turn_for(RIGHT, 120, DEGREES)

# VR threads — Do not delete
vr_thread(main)

Getters #

cabeçalho #

A direção indica o rumo para o qual o robô está virado, medida em graus. O comando heading devolve a direção atual do robô, variando de 0 a 359,99 graus.

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

Usage:
drivetrain.heading(units)

Parâmetros	Descrição
`units`	Opcional. Unidade de medida do cabeçalho: `DEGREES` (padrão).

def main():
    # Display the heading after turning
    drivetrain.turn_for(RIGHT, 450, DEGREES)
    brain.screen.print("Heading: ")
    brain.screen.print(drivetrain.heading(DEGREES))

# VR threads — Do not delete
vr_thread(main)

rotação #

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 rotation devolve a rotação atual 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.

Usage:
drivetrain.rotation(units)

Parâmetros	Descrição
`units`	Opcional. Unidade de rotação: `DEGREES` (padrão).

def main():
    # Display the rotation after turning
    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á_concluído #

is_done 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 Drivetrain que têm o parâmetro wait : drive_for, turn_for, turn_to_heading, e turn_to_rotation.

Usage:
drivetrain.is_done()

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

está_em_movimento #

is_moving devolve um valor booleano indicando se o robô está em movimento. Isto pode ser utilizado para controlar o tempo de outras ações com base no movimento do robô.

True — O robô está em movimento.
False — O robô não se está a mover.

Usage:
drivetrain.is_moving()

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

velocidade #

A velocidade velocity devolve a velocidade de deslocação do robô, em percentagem, de -100% a 100%.

Usage:
drivetrain.velocity(units)

Parâmetros	Descrição
`units`	Opcional. Unidade de velocidade: `PERCENT` (padrão).

Exemplo

def main():
    # Display the velocity after driving
    drivetrain.drive_for(FORWARD, 150, MM)
    brain.screen.print("Velocity: ")
    brain.screen.print(drivetrain.velocity(PERCENT))

Movimento #

O Disco utiliza o grupo motor de entrada para rodar as rodas de entrada, permitindo que os discos sejam recolhidos e pontuados. As mesmas rodas também podem fazer girar os rolos de campo quando entram em contacto com eles.

As descrições de direção explicam como cada direção movimenta o grupo do motor de admissão no Disco.

Ações #

rodar #

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

Usage:
intake_motor_group.spin(direction)

Parâmetros

Descrição

direction

Sentido de rotação do grupo motor:

FORWARD — Roda no sentido de admissão.
REVERSE — Gira no sentido de exaustão.

def main():
    # Spin the intake forward then stop
    intake_motor_group.spin(FORWARD)
    wait(0.5, SECONDS)
    intake_motor_group.stop()

# VR threads — Do not delete
vr_thread(main)

rodar_para #

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

Usage:
intake_motor_group.spin_for(direction, distance, units, wait)

Parâmetros	Descrição
`direction`	Sentido de rotação do grupo motor: `FORWARD` — Roda no sentido de admissão. `REVERSE` — Gira no sentido de exaustão.
`distance`	Distância percorrida pelo grupo de motores. `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 grupo de motores termine de rodar antes de executar a linha de código seguinte. `wait=False` — Faz com que a próxima linha de código seja executada imediatamente.

def main():
    # Spin the intake forward then stop
    intake_motor_group.spin_for(FORWARD, 360, DEGREES)

# VR threads — Do not delete
vr_thread(main)

rodar para a posição #

spin_to_position roda um grupo de motores para uma posição específica.

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

Os valores de posição são absolutos. Isto significa que a direção da rotação depende da posição atual do grupo de motores.

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

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

Parâmetros	Descrição
`angle`	O valor da posição para a qual o grupo de motores 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 grupo de motores termine de rodar antes de executar a linha de código seguinte. `wait=False` — Faz com que a próxima linha de código seja executada imediatamente.

Parâmetros

Descrição

angle

O valor da posição para a qual o grupo de motores 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 grupo de motores termine de rodar antes de executar a linha de código seguinte.
wait=False — Faz com que a próxima linha de código seja executada imediatamente.

def main():
    # Spin the intake forward then stop
    intake_motor_group.spin_to_position(55, DEGREES)

# VR threads — Do not delete
vr_thread(main)

parar #

stop impede que um grupo de motores gire.

Usage:
intake_motor_group.stop()

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

def main():
    # Spin the intake forward then stop
    intake_motor_group.spin(FORWARD)
    wait(0.5, SECONDS)
    intake_motor_group.stop()

# VR threads — Do not delete
vr_thread(main)

Mutantes #

definir_posição #

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

Por exemplo, se um grupo de motores tiver rodado 180 graus, definir a posição para 0 graus irá repor essa posição de 180 para 0 graus. Em seguida, o grupo de motores poderá rodar para posições com base neste novo valor.

Usage:
intake_motor_group.set_position(position, units)

Parâmetros	Descrição
`position`	O valor de posição a definir para o grupo de motores. `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`.

def main():
    # Spin the intake forward then stop
    intake_motor_group.set_position(90, DEGREES)
    intake_motor_group.spin_to_position(0, DEGREES)

# VR threads — Do not delete
vr_thread(main)

definir_velocidade #

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

Cada projeto começa com cada grupo de motores a rodar a 50% da velocidade por defeito.

Nota: Uma velocidade mais elevada faz com que o grupo de motores gire mais rapidamente, mas pode ser menos preciso. Uma velocidade mais baixa faz com que o grupo de motores gire mais devagar, mas pode ser mais preciso.

Usage:
intake_motor_group.set_velocity(velocity, units)

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`).
`units`	A unidade de velocidade: `PERCENT`.

def main():
    # Spin the intake forward then stop
    intake_motor_group.set_velocity(75, PERCENT)
    intake_motor_group.spin_to_position(180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

definir_tempo limite #

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

Usage:
intake_motor_group.set_timeout(value, units)

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

def main():
    # Spin the intake forward then stop
    intake_motor_group.set_timeout(2, SECONDS)
    intake_motor_group.spin_to_position(270, DEGREES)

# VR threads — Do not delete
vr_thread(main)

Getters #

está_concluído #

is_done devolve um valor booleano indicando se o grupo de motores terminou de se mover. Isto pode ser utilizado para controlar o tempo de outros comportamentos com base no movimento do grupo de motores.

True — O grupo motor terminou de se mover.
False — O grupo motor ainda se está a mover.

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:
intake_motor_group.is_done()

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

está a girar #

is_spinning retorna se o grupo de motores está a rodar, como um valor booleano. Isto pode ser utilizado para controlar o tempo de outros comportamentos com base no movimento do grupo de motores.

True — O grupo motor está a rodar.
False — O grupo 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:
intake_motor_group.is_spinning()

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

posição #

A posição de um grupo de motores é o quanto ele rodou, medido em DEGREES ou TURNSUma volta equivale a 360 graus. position devolve a posição atual do grupo de motores.

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

Usage:
intake_motor_group.position(units)

Parâmetros	Descrição
`units`	A unidade para voltar à posição do grupo de motores em: `DEGREES` ou `TURNS`.

velocidade #

A velocidade velocity o grupo de motores está a rodar.

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

Usage:
intake_motor_group.velocity(units)

Parâmetros	Descrição
`units`	A unidade de velocidade a devolver: `PERCENT`.

Consola #

O Console apresenta texto, números e valores de variáveis enquanto um projeto está a ser executado. Os métodos da Consola também podem mover o cursor para uma nova linha, limpar a Consola e adicionar variáveis ou valores de sensores ao separador Monitor.

Imprimir #

cérebro.tela.impressão #

brain.screen.print apresenta texto, números ou valores de variáveis na Consola utilizando a posição atual do cursor.

Utilize brain.screen.next_row quando pretender que o próximo valor impresso comece numa nova linha.

Usage:
brain.screen.print(value)

Parâmetros	Descrição
`value`	O texto, o número ou o valor da variável a apresentar na Consola.

def main():
    # Display a message in the Console
    brain.screen.print("Hello, robot!")

# VR threads — Do not delete
vr_thread(main)

A consola VEXcode, mostrando a consola e o texto "Olá, robô!" apresentado.

cérebro.ecrã.próxima_linha #

brain.screen.next_row move o cursor para a coluna 1 na linha seguinte da Consola. O próximo valor impresso aparecerá nessa linha.

Usage:
brain.screen.next_row()

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

A consola VEXcode, mostrando a consola e o texto "Linha 1" apresentado na primeira linha e "Linha 2" na segunda linha.

cérebro.ecrã.limpar_ecrã #

brain.screen.clear_screen limpa todas as linhas da Consola e move o cursor de volta para a Linha 1.

Usage:
brain.screen.clear_screen()

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

variável_de_monitorização #

monitor_variable adiciona uma ou mais variáveis predefinidas ao separador Monitor do VEXcode. Isto permite observar a alteração no valor de uma variável enquanto um projeto está a ser executado.

As variáveis devem ser globais para monitor_variable . Forneça o nome de cada variável como uma string.

Usage:
monitor_variable(“variable”)
monitor_variable(“variable1”, “variable2”)

Parâmetros	Descrição
`variable`	O nome de uma variável global predefinida a monitorizar, fornecido como uma string. Para monitorizar mais do que uma variável, separe cada nome de variável com uma vírgula.

def main():
    # Monitor the amount of loops
    global loops
    monitor_variable("loops")

    # Drive in a square 3 times
    for loops in range(12):
        drivetrain.turn_for(RIGHT, 90, DEGREES)
        drivetrain.drive_for(FORWARD, 150, MM)

# VR threads — Do not delete
vr_thread(main)

sensor_monitor #

O comando monitor_sensor adiciona um ou mais valores de sensores ao separador Monitor do VEXcode. Isto permite observar as alterações nos valores dos sensores enquanto um projeto está a ser executado.

Forneça o valor de cada sensor como uma string.

Usage:
monitor_sensor(“sensor”)
monitor_sensor(“sensor1”, “sensor2”)

Parâmetros	Descrição
`sensor`	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: Brain `brain.timer.time` Drivetrain `drivetrain.is_done` `drivetrain.is_moving` `drivetrain.heading` `drivetrain.rotation` `drivetrain.velocity_rpm` `drivetrain.velocity_percent` Intake Motor Group `intake_motor_group.is_done` `intake_motor_group.is_spinning` `intake_motor_group.position_degrees` `intake_motor_group.position_turns` `intake_motor_group.velocity_rpm` `intake_motor_group.velocity_percent` Fork Motor Group `fork_motor_group.is_done` `fork_motor_group.is_spinning` `fork_motor_group.position_degrees` `fork_motor_group.position_turns` `fork_motor_group.velocity_rpm` `fork_motor_group.velocity_percent` Bottom Distance Sensor `bottom_distance.is_object_detected` `bottom_distance.object_distance_mm` `bottom_distance.object_distance_inches` Left Distance Sensor `left_distance.is_object_detected` `left_distance.object_distance_mm` `left_distance.object_distance_inches` Center Distance Sensor `center_distance.is_object_detected` `center_distance.object_distance_mm` `center_distance.object_distance_inches` Right Distance Sensor `right_distance.is_object_detected` `right_distance.object_distance_mm` `right_distance.object_distance_inches` Line Trackers `bottom_line_tracker.reflectivity` `middle_line_tracker.reflectivity` `top_line_tracker.reflectivity` Roller Optical Sensor `roller_optical.is_near_object` `roller_optical.color` `roller_optical.brightness` `roller_optical.hue` Optical Sensor `optical.is_near_object` `optical.color` `optical.brightness` `optical.hue` GPS Sensor `gps.position_mm` `gps.position_inches` `gps.heading` Rotation Sensor `rotation.angle` `rotation.position`

Parâmetros

Descrição

sensor

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:

Brain
- brain.timer.time
Drivetrain
- drivetrain.is_done
- drivetrain.is_moving
- drivetrain.heading
- drivetrain.rotation
- drivetrain.velocity_rpm
- drivetrain.velocity_percent
Intake Motor Group
- intake_motor_group.is_done
- intake_motor_group.is_spinning
- intake_motor_group.position_degrees
- intake_motor_group.position_turns
- intake_motor_group.velocity_rpm
- intake_motor_group.velocity_percent
Fork Motor Group
- fork_motor_group.is_done
- fork_motor_group.is_spinning
- fork_motor_group.position_degrees
- fork_motor_group.position_turns
- fork_motor_group.velocity_rpm
- fork_motor_group.velocity_percent
Bottom Distance Sensor
- bottom_distance.is_object_detected
- bottom_distance.object_distance_mm
- bottom_distance.object_distance_inches
Left Distance Sensor
- left_distance.is_object_detected
- left_distance.object_distance_mm
- left_distance.object_distance_inches
Center Distance Sensor
- center_distance.is_object_detected
- center_distance.object_distance_mm
- center_distance.object_distance_inches
Right Distance Sensor
- right_distance.is_object_detected
- right_distance.object_distance_mm
- right_distance.object_distance_inches
Line Trackers
- bottom_line_tracker.reflectivity
- middle_line_tracker.reflectivity
- top_line_tracker.reflectivity
Roller Optical Sensor
- roller_optical.is_near_object
- roller_optical.color
- roller_optical.brightness
- roller_optical.hue
Optical Sensor
- optical.is_near_object
- optical.color
- optical.brightness
- optical.hue
GPS Sensor
- gps.position_mm
- gps.position_inches
- gps.heading
Rotation Sensor
- rotation.angle
- rotation.position

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)

Sensação #

Óptico #

está_perto_do_objeto #

is_near_object devolve um valor booleano indicando se o sensor ótico detetou ou não um objeto dentro do alcance.

True – O sensor ótico deteta um objeto.
False – O sensor ótico não detetou qualquer objeto.

Usage:
roller_optical.is_near_object()

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

cor #

A função color devolve uma instância de uma classe Color , com base no valor de matiz detectado. Estas instâncias podem ser comparadas com objetos Color predefinidos para criar instruções condicionais.

As cores possíveis são:

NONE
RED - Um valor de matiz entre 340° - 20°
GREEN - Um valor de matiz entre 80° - 140°
BLUE - Um valor de matiz entre 200° - 240°
YELLOW - Um valor de matiz entre 40° e 60°
ORANGE - Um valor de matiz entre 20° e 40°
PURPLE - Um valor de matiz entre 240° - 280°
CYAN - Um valor de matiz entre 140° - 200°

Nota: O sensor ótico procura intervalos de tonalidade que correspondam à cor especificada. Para detetar intervalos de matiz específicos, consulte hue.

Usage:
roller_optical.color()

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

brilho #

brightness devolve a quantidade de luz reflectida pelo objecto como um decimal (float) que representa uma percentagem.

Uma percentagem mais elevada significa que mais luz é refletida de volta para o sensor ótico. Uma percentagem mais baixa significa que menos luz é refletida de volta.

Usage:
roller_optical.brightness()

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

matiz #

hue devolve o valor de matiz da cor detectada como um decimal (float) de 0 a 359.

O matiz é uma forma de descrever a cor utilizando números num círculo cromático.

Uma roda de cores circular exibindo um espectro completo de tonalidades rotuladas com valores em graus em torno do perímetro, aumentando em incrementos de 30 graus de 0° no topo até 360°.

Usage:
roller_optical.hue()

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

objeto_detetado #

object_detected regista uma função a ser chamada sempre que o Sensor Óptico detete um novo objeto.

Usage:
roller_optical.object_detected(callback, arg)

Parâmetros	Descrição
`callback`	Uma função previamente definida que é executada quando o Sensor Óptico deteta um novo objeto.
`arg`	Opcional. Uma tupla contendo argumentos para passar para a função de callback. Consulte Utilizar funções com parâmetros para obter mais informações.

objeto_perdido #

object_lost regista uma função a ser chamada sempre que o sensor óptico perder um objecto detectado.

Usage:
roller_optical.object_lost(callback, arg)

Parâmetros	Descrição
`callback`	Uma função previamente definida que é executada quando o sensor óptico perde um objecto detectado.
`arg`	Opcional. Uma tupla contendo argumentos para passar para a função de callback. Consulte Utilizar funções com parâmetros para obter mais informações.

GPS #

posição x #

x_position devolve a coordenada x atual de um sensor GPS (Game Positioning System™) no campo.

Usage:
gps.x_position(units)

Parâmetros	Descrição
unidades	A unidade do valor de deslocamento: `INCHES` ou `MM`

posição_y #

y_position devolve a coordenada y atual de um sensor GPS (Game Positioning System™) no campo.

Usage:
gps.y_position(units)

Parâmetros	Descrição
unidades	A unidade do valor de deslocamento: `INCHES` ou `MM`

cabeçalho #

heading devolve a direcção para a qual o robô está actualmente virado, com base nas leituras do sensor GPS (Game Positioning System™) de 0 a 359 graus.

Usage:
gps.heading()

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

Rastreador de linha #

refletividade #

A refletividade reflectivity de luz refletida pela superfície em percentagem.

0% de refletividade significa que o objeto está demasiado escuro.
Uma refletividade de 100% significa que o objeto é demasiado brilhante.

Utilização:
Um dos três objetos line_tracker disponíveis pode ser utilizado com este método, como se mostra abaixo:

rastreador_de_linhas	Comando
`top_line_tracker`	`top_line_tracker.reflectivity(units)` — Rastreador de Linha Superior
`middle_line_tracker`	`middle_line_tracker.reflectivity(units)` — Rastreador de Linha do Meio
`bottom_line_tracker`	`bottom_line_tracker.reflectivity(units)` — Bottom Line Tracker

Parâmetro	Descrição
unidades	Opcional. Unidade de medida da reflectividade: `PERCENT` (padrão)

Parâmetro

Descrição

unidades

Opcional. Unidade de medida da reflectividade:

PERCENT (padrão)