Python específico para robôs#

Introdução #

O robô herói, Swish, inclui uma opção de motor, uma opção de grupo de motores e o sensor ótico.

Todos os métodos VR padrão do VEXcode estão disponíveis para utilização no IQ 24-25 Rapid Relay 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 motor e o grupo de motores do robô.

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

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`	A unidade de distância: `INCHES` 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`	Unidade de rotação: `DEGREES`.
`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`	Unidade de rotação: `DEGREES`.
`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`	Unidade de rotação: `DEGREES`.
`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`	Unidade de cabeçalho: `DEGREES`.

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`	Unidade de rotação: `DEGREES`.

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

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

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`	Unidade de cabeçalho: `DEGREES`.

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`	Unidade de rotação: `DEGREES`.

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

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 #

Swish utiliza o motor de entrada para recolher as bolas e movê-las para a catapulta. O conjunto do motor da catapulta baixa e liberta o braço da catapulta para lançar as bolas.

Cada motor e grupo de motores possui o seu próprio comportamento de direção. As descrições de direção explicam como cada direção movimenta esse motor ou grupo de motores no Swish.

Ações #

rodar #

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

Utilização:
Um dos dois objetos de motor ou grupo de motores disponíveis pode ser utilizado com este método, como se mostra abaixo:

motor	Comando
`intake_motor`	`intake_motor.spin(direction)` — Motor de Admissão
`catapult_group`	`catapult_group.spin(direction)` — Grupo de Catapultas

Parâmetros

Descrição

direction

Sentido de rotação do motor ou do grupo de motores:

FORWARD — Roda o motor de entrada no sentido de entrada ou baixa o grupo de catapulta.
REVERSE — Roda o motor de entrada no sentido de saída ou liberta o grupo de catapulta.

def main():
    # Spin the Intake Motor to bring a Ball onto the Catapult
    intake_motor.spin(FORWARD)
    wait(2, SECONDS)
    intake_motor.stop()

# VR threads — Do not delete
vr_thread(main)

rodar_para #

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

Utilização:
Um dos dois objetos de motor ou grupo de motores disponíveis pode ser utilizado com este método, como se mostra abaixo:

motor	Comando
`intake_motor`	`intake_motor.spin_for(direction, distance, units, wait=True)` — Motor de Admissão
`catapult_group`	`catapult_group.spin_for(direction, distance, units, wait=True)` — Grupo de Catapultas

Parâmetros	Descrição
`direction`	Sentido de rotação do motor ou do grupo de motores: `FORWARD` — Roda o motor de entrada no sentido de entrada ou baixa o grupo de catapulta. `REVERSE` — Roda o motor de entrada no sentido de saída ou liberta o grupo de catapulta.
`distance`	A distância a que o motor ou grupo de motores 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 ou 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():
    # Release the preloaded Ball
    catapult_group.spin_for(REVERSE, 5, DEGREES)
    # Lower the Catapult to prepare to load another Ball
    catapult_group.spin_for(FORWARD, 1350, DEGREES)

# VR threads — Do not delete
vr_thread(main)

rodar para a posição #

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

A posição de um motor ou grupo de motores é 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 ou do grupo de motores é definida para 0 graus. A posição do motor ou 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 motor ou do grupo de motores.

Por exemplo, se o motor ou o grupo de motores 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.

Utilização:
Um dos dois objetos de motor ou grupo de motores disponíveis pode ser utilizado com este método, como se mostra abaixo:

motor	Comando
`intake_motor`	`intake_motor.spin_to_position(angle, units, wait=True)` — Motor de Admissão
`catapult_group`	`catapult_group.spin_to_position(angle, units, wait=True)` — Grupo de Catapultas

Parâmetros	Descrição
`angle`	O valor da posição para a qual o motor ou 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 motor ou 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 motor ou 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 motor ou 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():
    # Release the preloaded Ball
    catapult_group.spin_to_position(-90, DEGREES)
    # Lower the Catapult to prepare to load another Ball
    catapult_group.spin_to_position(1260, DEGREES)

# VR threads — Do not delete
vr_thread(main)

motor de paragem #

stop impede que um motor ou um grupo de motores gire.

Utilização:
Um dos dois objetos de motor ou grupo de motores disponíveis pode ser utilizado com este método, como se mostra abaixo:

motor	Comando
`intake_motor`	`intake_motor.stop()` — Motor de Admissão
`catapult_group`	`catapult_group.stop()` — Grupo de Catapultas

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

def main():
    # Spin the Intake Motor to bring a Ball onto the Catapult
    intake_motor.spin(FORWARD)
    wait(2, SECONDS)
    intake_motor.stop()

# VR threads — Do not delete
vr_thread(main)

Mutantes #

definir_posição #

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

Por exemplo, se um motor ou 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 motor ou o grupo de motores poderá rodar para posições com base neste novo valor.

Utilização:
Um dos dois objetos de motor ou grupo de motores disponíveis pode ser utilizado com este método, como se mostra abaixo:

motor	Comando
`intake_motor`	`intake_motor.set_position(position, units)` — Motor de Admissão
`catapult_group`	`catapult_group.set_position(position, units)` — Grupo de Catapultas

Parâmetros	Descrição
`position`	O valor de posição a definir para o motor ou 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():
    # Lower the Catapult to prepare to load another Ball
    catapult_group.spin_to_position(1260, DEGREES)
    # Set the new Catapult position to be 0 degrees
    catapult_group.set_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 motor ou grupo de motores. Uma percentagem mais elevada faz com que o motor ou o grupo de motores gire mais rapidamente, enquanto uma percentagem mais baixa faz com que o motor ou o grupo de motores gire mais lentamente.

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

Nota: Uma velocidade mais elevada faz com que o motor ou o grupo de motores gire mais rapidamente, mas pode resultar numa menor precisão. Uma velocidade mais baixa faz com que o motor ou o grupo de motores gire mais lentamente, mas pode resultar numa maior precisão.

Utilização:
Um dos dois objetos de motor ou grupo de motores disponíveis pode ser utilizado com este método, como se mostra abaixo:

motor	Comando
`intake_motor`	`intake_motor.set_velocity(velocity, units)` — Motor de Admissão
`catapult_group`	`catapult_group.set_velocity(velocity, units)` — Grupo de Catapultas

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

def main():
    # Start spinning the Intake Motor to prepare for picking up a Ball
    intake_motor.set_velocity(100, PERCENT)
    intake_motor.spin(FORWARD)

# VR threads — Do not delete
vr_thread(main)

definir_tempo limite #

O parâmetro set_timeout define durante quanto tempo um motor ou grupo de motores tentará completar um movimento. Se o motor ou 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 motor ou o grupo de motores fique preso num movimento.

Utilização:
Um dos dois objetos de motor ou grupo de motores disponíveis pode ser utilizado com este método, como se mostra abaixo:

motor	Comando
`intake_motor`	`intake_motor.set_timeout(value, units)` — Motor de Admissão
`catapult_group`	`catapult_group.set_timeout(value, units)` — Grupo de Catapultas

Parâmetros	Descrição
`value`	O tempo que o motor ou o grupo de motores 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():
    # Limit how long the Catapult waits to reach its target
    catapult_group.set_timeout(2, SECONDS)
    catapult_group.spin_for(FORWARD, 2160, DEGREES)

# VR threads — Do not delete
vr_thread(main)

Getters #

está_concluído #

is_done retorna se o motor ou o grupo de motores terminou de se mover, como um valor booleano. Isto pode ser utilizado para controlar o tempo de outros comportamentos com base no movimento do motor ou do grupo de motores.

True — O motor ou o grupo de motores terminou de se mover.
False — O motor ou grupo 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.

Utilização:
Um dos dois objetos de motor ou grupo de motores disponíveis pode ser utilizado com este método, como se mostra abaixo:

motor	Comando
`intake_motor`	`intake_motor.is_done()` — Motor de Admissão
`catapult_group`	`catapult_group.is_done()` — Grupo de Catapultas

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

está a girar #

is_spinning retorna se o motor ou 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 motor ou do grupo de motores.

True — O motor ou o grupo de motores está a rodar.
False — O motor ou o grupo de motores 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.

Utilização:
Um dos dois objetos de motor ou grupo de motores disponíveis pode ser utilizado com este método, como se mostra abaixo:

motor	Comando
`intake_motor`	`intake_motor.is_spinning()` — Motor de Admissão
`catapult_group`	`catapult_group.is_spinning()` — Grupo de Catapultas

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

posição #

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

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

Utilização:
Um dos dois objetos de motor ou grupo de motores disponíveis pode ser utilizado com este método, como se mostra abaixo:

motor	Comando
`intake_motor`	`intake_motor.position(units)` — Motor de Admissão
`catapult_group`	`catapult_group.position(units)` — Grupo de Catapultas

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

def main():
    # Lower the Catapult to prepare to load another Ball
    while not catapult_group.position(DEGREES) == 1260:
        catapult_group.spin(FORWARD)

# VR threads — Do not delete
vr_thread(main)

velocidade #

A velocidade velocity indica a rapidez com que o motor ou o grupo de motores está a rodar.

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

Utilização:
Um dos dois objetos de motor ou grupo de motores disponíveis pode ser utilizado com este método, como se mostra abaixo:

motor	Comando
`intake_motor`	`intake_motor.velocity(units)` — Motor de Admissão
`catapult_group`	`catapult_group.velocity(units)` — Grupo de Catapultas

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

def main():
    # Print the current Catapult velocity
    brain.screen.print(catapult_group.velocity(PERCENT))

# VR threads — Do not delete
vr_thread(main)

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. Comporta-se como print na página da API da Consola.

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`	O valor do sensor a monitorizar, fornecido como uma string. Para monitorizar mais do que um valor de sensor, separe cada valor com uma vírgula. Os identificadores de sensores suportados incluem: Cérebro `brain.timer.time` Transmissão `drivetrain.is_done` `drivetrain.is_moving` `drivetrain.heading` `drivetrain.rotation` `drivetrain.velocity_rpm` `drivetrain.velocity_percent` Motor do Braço `arm_motor.is_done` `arm_motor.is_spinning` `arm_motor.position_degrees` `arm_motor.position_turns` `arm_motor.velocity_rpm` `arm_motor.velocity_percent` Grupo de Motores do Braço `arm_motor_group.is_done` `arm_motor_group.is_spinning` `arm_motor_group.position_degrees` `arm_motor_group.position_turns` `arm_motor_group.velocity_rpm` `arm_motor_group.velocity_percent` Motor de Admissão `intake_motor.is_done` `intake_motor.is_spinning` `intake_motor.position_degrees` `intake_motor.position_turns` `intake_motor.velocity_rpm` `intake_motor.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` Catapult Motor `catapult_motor.is_done` `catapult_motor.is_spinning` `catapult_motor.position_degrees` `catapult_motor.position_turns` `catapult_motor.velocity_rpm` `catapult_motor.velocity_percent` Catapult Tension Motor `catapult_tension_motor.is_done` `catapult_tension_motor.is_spinning` `catapult_tension_motor.position_degrees` `catapult_tension_motor.position_turns` `catapult_tension_motor.velocity_rpm` `catapult_tension_motor.velocity_percent` Bumpers `intake_bumper.pressing` `bumper.pressing` Sensor de Distância Frontal `front_distance.is_object_detected` `front_distance.object_distance_mm` `front_distance.object_distance_inches` Sensor Óptico Frontal `front_optical.is_near_object` `front_optical.color` `front_optical.brightness` `front_optical.hue` Sensor de Cor `color.is_near_object` `color.color` `color.brightness` `color.hue`

Parâmetros

Descrição

sensor

O valor do sensor a monitorizar, fornecido como uma string. Para monitorizar mais do que um valor de sensor, separe cada valor com uma vírgula. Os identificadores de sensores suportados incluem:

Cérebro
- brain.timer.time
Transmissão
- drivetrain.is_done
- drivetrain.is_moving
- drivetrain.heading
- drivetrain.rotation
- drivetrain.velocity_rpm
- drivetrain.velocity_percent
Motor do Braço
- arm_motor.is_done
- arm_motor.is_spinning
- arm_motor.position_degrees
- arm_motor.position_turns
- arm_motor.velocity_rpm
- arm_motor.velocity_percent
Grupo de Motores do Braço
- arm_motor_group.is_done
- arm_motor_group.is_spinning
- arm_motor_group.position_degrees
- arm_motor_group.position_turns
- arm_motor_group.velocity_rpm
- arm_motor_group.velocity_percent
Motor de Admissão
- intake_motor.is_done
- intake_motor.is_spinning
- intake_motor.position_degrees
- intake_motor.position_turns
- intake_motor.velocity_rpm
- intake_motor.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
Catapult Motor
- catapult_motor.is_done
- catapult_motor.is_spinning
- catapult_motor.position_degrees
- catapult_motor.position_turns
- catapult_motor.velocity_rpm
- catapult_motor.velocity_percent
Catapult Tension Motor
- catapult_tension_motor.is_done
- catapult_tension_motor.is_spinning
- catapult_tension_motor.position_degrees
- catapult_tension_motor.position_turns
- catapult_tension_motor.velocity_rpm
- catapult_tension_motor.velocity_percent
Bumpers
- intake_bumper.pressing
- bumper.pressing
Sensor de Distância Frontal
- front_distance.is_object_detected
- front_distance.object_distance_mm
- front_distance.object_distance_inches
Sensor Óptico Frontal
- front_optical.is_near_object
- front_optical.color
- front_optical.brightness
- front_optical.hue
Sensor de Cor
- color.is_near_object
- color.color
- color.brightness
- color.hue

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:
intake_optical.is_near_object()

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

def main():
    # Launch a loaded Ball once the Intake Optical Sensor detects a Ball
    if intake_optical.is_near_object():
        catapult_group.spin_for(REVERSE, 5, DEGREES)

# VR threads — Do not delete
vr_thread(main)

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:
intake_optical.color()

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

def main():
    # Launch a loaded Ball once yellow is detected in the Intake
    if intake_optical.color() == YELLOW:
        catapult_group.spin_for(REVERSE, 5, DEGREES)

# VR threads — Do not delete
vr_thread(main)

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:
intake_optical.brightness()

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

def main():
    # Launch a loaded Ball once the Intake Optical Sensor sees a Ball
    if intake_optical.brightness() > 0:
        catapult_group.spin_for(REVERSE, 5, DEGREES)

# VR threads — Do not delete
vr_thread(main)

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 graus no topo até 360 graus.

Usage:
intake_optical.hue()

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

def main():
    # Launch a loaded Ball once the Intake Optical Sensor reports a hue value
    if intake_optical.hue() > 100:
        catapult_group.spin_for(REVERSE, 5, DEGREES)

# VR threads — Do not delete
vr_thread(main)

objeto_detetado #

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

Usage:
intake_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.

def launch_ball():
    catapult_group.spin_for(REVERSE, 5, DEGREES)

def main():
    # Launch the Ball when the Intake Optical Sensor detects an object
    intake_optical.object_detected(launch_ball)

# VR threads — Do not delete
vr_thread(main)

objeto_perdido #

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

Usage:
intake_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.

def lower_catapult():
    catapult_group.spin_to_position(1260, DEGREES)

def main():
    # Lower the Catapult when the Intake Optical Sensor no longer detects an object
    intake_optical.object_lost(lower_catapult)

# VR threads — Do not delete
vr_thread(main)