Python específico para robôs#

Introdução #

O Hero Bot, Dex, inclui duas opções de motor, um sensor de visão com inteligência artificial, um sensor ótico e um sensor de sistema de posicionamento para jogos (GPS).

Todos os métodos VR padrão do VEXcode estão disponíveis para utilização no V5 25-26 Push Back 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 indefinidamente.
- 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 os motores do robô.

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

Visão com IA - Capte e analise objetos utilizando o sensor de Visão com IA.

Obteve
- take_snapshot – Retorna uma tupla de objectos detectados para uma assinatura específica.
Propriedades
- width – Largura do objecto detectado em pixéis.
- height – Altura do objecto detectado em pixéis.
- centerX – Posição X do centro do objecto em pixéis.
- centerY – Posição Y do centro do objecto em pixéis.
- originX – Posição X do canto superior esquerdo do objeto em pixéis.
- originY – Posição Y do canto superior esquerdo do objeto em pixéis.
- id – Classificação ou ID da etiqueta do objeto.

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.

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 #

Dex utiliza o motor de entrada para puxar os blocos para dentro do robô. O motor da passadeira move os blocos da entrada para o topo do robô, para que possam ser empurrados em direção a um objetivo.

Cada motor possui o seu próprio comportamento de direção. As descrições das direções explicam como cada direção movimenta o motor no Dex.

Ações #

rodar #

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

Utilização:
Um dos dois objetos motorizados 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
`conveyor_motor`	`conveyor_motor.spin(direction)` — Motor da passadeira

Parâmetros

Descrição

direction

Sentido de rotação do motor:

FORWARD — Roda o motor da correia para cima ou roda o motor de entrada no sentido de entrada.
REVERSE — Roda o motor da correia para baixo ou roda o motor de entrada no sentido de saída.

def main():
    # Pick up a second Block
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 350, MM)

# VR threads — Do not delete
vr_thread(main)

rodar_para #

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

Utilização:
Um dos dois objetos motorizados 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)` — Motor de Admissão
`conveyor_motor`	`conveyor_motor.spin_for(direction, distance, units, wait)` — Motor da passadeira

Parâmetros	Descrição
`direction`	Sentido de rotação do motor: `FORWARD` — Roda o motor da correia para cima ou roda o motor de entrada no sentido de entrada. `REVERSE` — Roda o motor da correia para baixo ou roda o motor de entrada no sentido de saída.
`distance`	A distância a que o motor roda. `DEGREES` utilize números inteiros. `TURNS` pode utilizar números inteiros ou decimais.
`units`	Opcional. A unidade de distância: `DEGREES` (padrão) ou `TURNS`.
`wait`	Opcional. `wait=True` (padrão) — Faz com que o projeto aguarde até que o motor termine de rodar antes de executar a linha de código seguinte. `wait=False` — Faz com que a próxima linha de código seja executada imediatamente.

def main():
    # Pick up a second Block
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 350, MM)

# VR threads — Do not delete
vr_thread(main)

rodar para a posição #

spin_to_position roda um motor para uma posição específica.

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

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

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

Utilização:
Um dos dois objetos motorizados 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
`conveyor_motor`	`conveyor_motor.spin_to_position(angle, units, wait=True)` — Motor da passadeira

Parâmetros	Descrição
`angle`	O valor da posição para a qual o motor irá rodar. `DEGREES` utilize números inteiros. `TURNS` pode utilizar números inteiros ou decimais.
`units`	Opcional. A unidade de posição: `DEGREES` (padrão) ou `TURNS`.
`wait`	Opcional. `wait=True` (padrão) — Faz com que o projeto aguarde até que o motor termine de rodar antes de executar a 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 irá rodar. DEGREES utilize números inteiros. TURNS pode utilizar números inteiros ou decimais.

units

Opcional. A unidade de posição: DEGREES (padrão) ou TURNS.

wait

Opcional.

wait=True (padrão) — Faz com que o projeto aguarde até que o motor termine de rodar antes de executar a linha de código seguinte.
wait=False — Faz com que a próxima linha de código seja executada imediatamente.

def main():
    # Pick up a second Block
    conveyor_motor.spin_to_position(150, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 350, MM)

# VR threads — Do not delete
vr_thread(main)

parar #

stop impede que um motor gire.

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

motor	Comando
`intake_motor`	`intake_motor.stop()` — Motor de Admissão
`conveyor_motor`	`conveyor_motor.stop()` — Motor da passadeira

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

def main():
    # Pick up a second Block
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 350, MM)
    intake_motor.stop()

# VR threads — Do not delete
vr_thread(main)

Mutantes #

definir_posição #

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

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

Utilização:
Um dos dois objetos motorizados 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
`conveyor_motor`	`conveyor_motor.set_position(position, units)` — Motor da passadeira

Parâmetros	Descrição
`position`	O valor de posição a definir para o motor. `DEGREES` utilize números inteiros. `TURNS` pode utilizar números inteiros ou decimais.
`units`	Opcional. A unidade de posição: `DEGREES` (padrão) ou `TURNS`.

def main():
    # Pick up a second Block
    conveyor_motor.set_position(-150, DEGREES)
    conveyor_motor.spin_to_position(0, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 350, MM)

# VR threads — Do not delete
vr_thread(main)

definir_velocidade #

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

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

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

Utilização:
Um dos dois objetos motorizados 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
`conveyor_motor`	`conveyor_motor.set_velocity(velocity, units)` — Motor da passadeira

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():
    # Pick up a second Block
    conveyor_motor.set_velocity(90, PERCENT)
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 400, MM)

# VR threads — Do not delete
vr_thread(main)

definir_tempo limite #

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

Utilização:
Um dos dois objetos motorizados 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
`conveyor_motor`	`conveyor_motor.set_timeout(value, units)` — Motor da passadeira

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

def main():
    # Pick up a second Block
    conveyor_motor.set_timeout(0.5, SECONDS)
    conveyor_motor.spin_to_position(1000, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 400, MM)

# VR threads — Do not delete
vr_thread(main)

Getters #

está_concluído #

is_done retorna se o motor 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.

True — O motor terminou de se mover.
False — O motor ainda 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 motorizados 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
`conveyor_motor`	`conveyor_motor.is_done()` — Motor da passadeira

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

def main():
    # Pick up a second Block
    conveyor_motor.spin_to_position(300, DEGREES, wait=False)
    wait(0.1, SECONDS)
    while not conveyor_motor.is_done():
        drivetrain.drive(FORWARD)
        intake_motor.spin(FORWARD)
        wait(5, MSEC)
    drivetrain.stop()
    intake_motor.stop()

# VR threads — Do not delete
vr_thread(main)

está a girar #

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

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

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

Utilização:
Um dos dois objetos motorizados 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
`conveyor_motor`	`conveyor_motor.is_spinning()` — Motor da passadeira

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

def main():
    # Pick up a second Block
    conveyor_motor.spin_to_position(300, DEGREES, wait=False)
    wait(0.1, SECONDS)
    while conveyor_motor.is_spinning():
        drivetrain.drive_for(FORWARD, 200, MM)
        intake_motor.spin(FORWARD)

# VR threads — Do not delete
vr_thread(main)

posição #

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

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

Utilização:
Um dos dois objetos motorizados 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
`conveyor_motor`	`conveyor_motor.position(units)` — Motor da passadeira

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

def main():
    # Pick up a second Block
    while conveyor_motor.position(DEGREES) < 150:
        conveyor_motor.spin(FORWARD)
        wait(2, MSEC)
    conveyor_motor.stop()
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 400, MM)

# VR threads — Do not delete
vr_thread(main)

velocidade #

A velocidade velocity o motor está a rodar.

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

Utilização:
Um dos dois objetos motorizados 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
`conveyor_motor`	`conveyor_motor.velocity(units)` — Motor da correia

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

def main():
    # Pick up a second block
    conveyor_motor.set_velocity(100, PERCENT)
    conveyor_motor.spin_to_position(300, DEGREES, wait=False)
    wait(0.2, SECONDS)
    brain.screen.print(conveyor_motor.velocity(PERCENT))
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 400, MM)

# VR threads — Do not delete
vr_thread(main)

Visão de IA #

Getters #

tirar_foto #

take_snapshot filtra os dados do quadro do sensor de visão de IA para uma única assinatura — uma descrição guardada de algo que o sensor pode reconhecer, como um elemento do jogo no campo — e devolve uma tupla.

A tupla armazena os objetos ordenados do maior para o menor por largura, começando no índice 0. As propriedades de cada objeto podem ser acedidas utilizando o seu índice. Uma tupla vazia é devolvida se nenhum objeto correspondente for detetado.

Usage:
ai_vision.take_snapshot(signature)

Parâmetros	Descrição
`signature`	Filtra o conjunto de dados para incluir apenas os dados da assinatura fornecida. Assinaturas disponíveis: `AiVision.ALL_AIOBJS` - Deteta blocos vermelhos e azuis.

Parâmetros

Descrição

signature

Filtra o conjunto de dados para incluir apenas os dados da assinatura fornecida. Assinaturas disponíveis:

AiVision.ALL_AIOBJS - Deteta blocos vermelhos e azuis.

def main():
    # If an object is detected, pick it up
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            intake_motor.spin(FORWARD)
            drivetrain.drive(FORWARD)
            while not bumper.pressing():
                wait(2, MSEC)
            drivetrain.stop()
            break

# VR threads — Do not delete
vr_thread(main)

Propriedades #

Existem sete propriedades que são incluídas em cada objeto armazenado numa tupla após take_snapshot ser utilizado.

All property values except .id describe the detected object’s position and size in the AI Vision Sensor’s view at the moment take_snapshot was used. These values are measured in pixels, based on the sensor’s 320 by 240 pixel resolution.

.largura #

.width devolve a largura do objeto detetado em pixéis, que é um número inteiro entre 1 e 320.

def main():
    # If an object is detected, approach and pick it up
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].width > 65:
                drivetrain.stop()
                break
            else:
                intake_motor.spin(FORWARD)
                drivetrain.drive(FORWARD)

# VR threads — Do not delete
vr_thread(main)

.altura #

.height devolve a altura do objeto detetado em pixéis, que é um número inteiro entre 1 e 240.

def main():
    # If an object is detected, approach and pick it up
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].height > 55:
                drivetrain.stop()
                break
            else:
                intake_motor.spin(FORWARD)
                drivetrain.drive(FORWARD)

# VR threads — Do not delete
vr_thread(main)

. centerX #

.centerX devolve a coordenada x do centro do objecto detectado em pixéis, que é um número inteiro entre 0 e 320.

def main():
    # Pick up a Block from the top left group
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    drivetrain.turn_for(LEFT, 80, DEGREES)
    drivetrain.drive_for(FORWARD, 200, MM)
    drivetrain.set_turn_velocity(20, PERCENT)
    drivetrain.turn(LEFT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if 140 < ai_objects[0].centerX < 180:
                intake_motor.spin(FORWARD)
                drivetrain.drive(FORWARD)
                while not bumper.pressing():
                    wait(2, MSEC)
                drivetrain.stop()

# VR threads — Do not delete
vr_thread(main)

. centerY #

.centerY devolve a coordenada y do centro do objecto detectado em pixéis, que é um número inteiro entre 0 e 240.

def main():
    # If an object is detected, approach and pick it up
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].centerY > 140:
                drivetrain.stop()
                break
            else:
                intake_motor.spin(FORWARD)
                drivetrain.drive(FORWARD)

# VR threads — Do not delete
vr_thread(main)

. origemX #

.originX devolve a coordenada x do canto superior esquerdo da caixa delimitadora do objeto detetado em pixéis, que é um número inteiro entre 0 e 320.

def main():
    # Pick up a Block from the top left group
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    drivetrain.turn_for(LEFT, 80, DEGREES)
    drivetrain.drive_for(FORWARD, 300, MM)
    drivetrain.set_turn_velocity(20, PERCENT)
    drivetrain.turn(RIGHT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if 100 < ai_objects[0].originX < 140:
                intake_motor.spin(FORWARD)
                drivetrain.drive(FORWARD)
                while not bumper.pressing():
                    wait(2, MSEC)
                drivetrain.stop()

# VR threads — Do not delete
vr_thread(main)

. origemY #

.originY devolve a coordenada y do canto superior esquerdo da caixa delimitadora do objeto detetado em pixéis, que é um número inteiro entre 0 e 240.

def main():
    # If an object is detected, approach and pick it up
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].originY > 120:
                drivetrain.stop()
                break
            else:
                intake_motor.spin(FORWARD)
                drivetrain.drive(FORWARD)

# VR threads — Do not delete
vr_thread(main)

. ia #

.id devolve o ID da classificação de IA detectada como um número inteiro.

Classificação por IA	eu ia	Assinatura
Bloco Azul	1	`GameElements.BLUE_BLOCK`
Bloco Vermelho	2	`GameElements.RED_BLOCK`

def main():
    # Pick up a Red Block from the top left group
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    drivetrain.turn_for(LEFT, 80, DEGREES)
    drivetrain.drive_for(FORWARD, 300, MM)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            drivetrain.drive(FORWARD)
            if (ai_objects[0].id) == 2:
                intake_motor.spin(FORWARD)
                while not bumper.pressing():
                    wait(2, MSEC)
                drivetrain.stop()
                break

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

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` Pusher Motor `pusher_motor.is_done` `pusher_motor.is_spinning` `pusher_motor.position` `pusher_motor.velocity` Arm Motor `arm_motor.is_done` `arm_motor.is_spinning` `arm_motor.position` `arm_motor.velocity` Front Distance Sensor `front_distance.is_object_detected` `front_distance.object_distance_mm` `front_distance.object_distance_inches` Front Optical Sensor `front_optical.is_near_object` `front_optical.color` `front_optical.brightness` `front_optical.hue` GPS Sensor `gps.position_mm` `gps.position_inches` `gps.heading` Pusher Rotation Sensor `pusher_rotation.angle` `pusher_rotation.position` AI Vision Sensor `ai_vision.object_count` `ai_vision.height` `ai_vision.width` `ai_vision.centerX` `ai_vision.centerY` `ai_vision.originX` `ai_vision.originY` `ai_vision.id`

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
Pusher Motor
- pusher_motor.is_done
- pusher_motor.is_spinning
- pusher_motor.position
- pusher_motor.velocity
Arm Motor
- arm_motor.is_done
- arm_motor.is_spinning
- arm_motor.position
- arm_motor.velocity
Front Distance Sensor
- front_distance.is_object_detected
- front_distance.object_distance_mm
- front_distance.object_distance_inches
Front Optical Sensor
- front_optical.is_near_object
- front_optical.color
- front_optical.brightness
- front_optical.hue
GPS Sensor
- gps.position_mm
- gps.position_inches
- gps.heading
Pusher Rotation Sensor
- pusher_rotation.angle
- pusher_rotation.position
AI Vision Sensor
- ai_vision.object_count
- ai_vision.height
- ai_vision.width
- ai_vision.centerX
- ai_vision.centerY
- ai_vision.originX
- ai_vision.originY
- ai_vision.id

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

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

def main():
    # Move the preloaded Block to the top of the Conveyor
    conveyor_motor.spin(FORWARD)
    while not optical.is_near_object():
        wait(2, MSEC)
    conveyor_motor.stop()

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

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

def main():
    # Pick up and move a Blue Block to the top of the Conveyor
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 360, MM)
    conveyor_motor.spin(FORWARD)
    while not optical.color() == BLUE:
        wait(2, MSEC)
    conveyor_motor.stop()

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

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

def main():
    # Move the preloaded Block to the top of the Conveyor
    conveyor_motor.spin(FORWARD)
    while not 0 < optical.brightness():
        wait(2, MSEC)
    conveyor_motor.stop()

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

Usage:
optical.hue()

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

def main():
    # Pick up and move a Blue Block to the top of the Conveyor
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 360, MM)
    conveyor_motor.spin(FORWARD)
    while not 220 < optical.hue() < 260:
        wait(2, MSEC)
    conveyor_motor.stop()

# 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:
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 ready_block():
  # Stop the conveyor when Block is at the Sensor
  conveyor_motor.stop()

def main():
  # Move the preloaded Block near the top of the Conveyor
  conveyor_motor.spin(FORWARD)
  optical.object_detected(ready_block)

# 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:
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 ready_block():
  # Stop the conveyor when Block is at the top
  conveyor_motor.stop()

def main():
  # Move the preloaded Block to the top of the Conveyor
  conveyor_motor.spin(FORWARD)
  optical.object_lost(ready_block)

# VR threads — Do not delete
vr_thread(main)

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`

def main():
    # Pick up a second Block
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive(FORWARD)
    while not gps.x_position(MM) > -795:
        wait(2, MSEC)
    drivetrain.stop()

# VR threads — Do not delete
vr_thread(main)

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`

def main():
    # Pick up a second Block
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive(FORWARD)
    while not -450 > gps.y_position(MM):
        wait(2, MSEC)
    drivetrain.stop()

# VR threads — Do not delete
vr_thread(main)

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.

def main():
    # Score the preloaded Block into a Center Goal
    drivetrain.set_turn_velocity(30, PERCENT)
    drivetrain.turn(LEFT)
    while not 40 > gps.heading():
        wait(2, MSEC)
    drivetrain.drive_for(FORWARD, 1000, MM)
    drivetrain.turn(RIGHT)
    while not gps.heading() > 310:
        wait(2, MSEC)
    drivetrain.drive_for(REVERSE, 400, MM)
    conveyor_motor.spin(FORWARD)

# VR threads — Do not delete
vr_thread(main)