Python específico para robôs

Introdução

O robô herói Snapshot inclui duas opções de motor e o sensor ótico.

Todos os métodos VR padrão do VEXcode estão disponíveis para utilização no IQ 22-23 Slapshot 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 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.

Eventos - Executar código quando um sensor muda de estado.

• Pára-choques

  • pressed - Regista uma função de callback para quando o Intake Bumper é premido.

  • released - Regista uma função de retorno de chamada para quando o pára-choques de entrada é libertado.

• Ó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.

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

• Pára-choques

  • pressing - Retorna se o botão de entrada está actualmente premido.

• Ó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.

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

Transmissão

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

O Snapshot utiliza o motor de entrada para recolher os discos ou rodá-los para marcar pontos ou soltá-los. O motor do braço levanta e baixa o braço para libertar os discos dos dispensadores e alcançar os elementos do campo.

Cada motor tem o seu próprio comportamento de direção. As descrições de condução explicam como cada condução move este motor no Snapshot.

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
arm_motor	arm_motor.spin(direction) — Motor do braço

Parâmetros	Descrição
direction	Sentido de rotação do motor: FORWARD — Roda o motor de admissão no sentido de admissão ou levanta o motor do braço. REVERSE — Roda o motor de admissão no sentido de escape ou baixa o motor do braço.

def main():
    # Spin the Intake Motor to collect a Disc
    intake_motor.spin(FORWARD)
    wait(1, SECONDS)
    intake_motor.stop()

# 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=True) — Motor de Admissão
arm_motor	arm_motor.spin_for(direction, distance, units, wait=True) — Motor do Braço

Parâmetros	Descrição
direction	Sentido de rotação do motor: FORWARD — Roda o motor de admissão no sentido de admissão ou levanta o motor do braço. REVERSE — Roda o motor de admissão no sentido de escape ou baixa o motor do braço.
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():
    # Collect the preloaded Disc
    intake_motor.spin_for(FORWARD, 180, DEGREES)

# 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
arm_motor	arm_motor.spin_to_position(angle, units, wait=True) — Motor do Braço

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():
    # Raise the Arm to reach over the barrier
    arm_motor.spin_to_position(600, DEGREES)

# VR threads — Do not delete
vr_thread(main)

motor de paragem

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
arm_motor	arm_motor.stop() — Braçar o motor

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

def main():
    # Raise the Arm briefly, then stop it
    arm_motor.spin(FORWARD)
    wait(1, SECONDS)
    arm_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
arm_motor	arm_motor.set_position(position, units) — Motor do braço

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():
    # Set the Intake Motor position, then return to 0 degrees
    intake_motor.set_position(180, DEGREES)
    intake_motor.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 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
arm_motor	arm_motor.set_velocity(velocity, units) — Motor do braço

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():
    # Set the Intake Motor speed before collecting a Disc
    intake_motor.set_velocity(75, PERCENT)
    intake_motor.spin_for(FORWARD, 180, DEGREES)

# 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
arm_motor	arm_motor.set_timeout(value, units) — Motor do braço

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():
    # Limit how long the Arm Motor waits to reach its target
    arm_motor.set_timeout(2, SECONDS)
    arm_motor.spin_for(FORWARD, 1080, DEGREES)

# 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
arm_motor	arm_motor.is_done() — Motor do braço

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

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
arm_motor	arm_motor.is_spinning() — Motor do braço

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

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
arm_motor	arm_motor.position(units) — Motor do Braço

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

def main():
    # Print the current Arm Motor position
    brain.screen.print(arm_motor.position(DEGREES))

# 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
arm_motor	arm_motor.velocity(units) — Motor do braço

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

def main():
    # Print the current Intake Motor velocity
    brain.screen.print(intake_motor.velocity(PERCENT))

# VR threads — Do not delete
vr_thread(main)

Eventos

para-choque

pressionado

Ao premir pressed regista uma função de retorno de chamada para quando o botão de entrada é premido.

Usage:
intake_bumper.pressed(callback)

Parâmetros	Descrição
callback	Uma função que será chamada quando o botão de entrada de ar for pressionado.

def stop_intake():
    intake_motor.stop()

def main():
    # Stop the Intake Motor when a Disc reaches the Intake Bumper
    intake_bumper.pressed(stop_intake)
    intake_motor.spin(FORWARD)

# VR threads — Do not delete
vr_thread(main)

lançado

released regista uma função de retorno de chamada para quando o pára-choques de entrada é libertado.

Usage:
intake_bumper.released(callback)

Parâmetros	Descrição
callback	Uma função que será chamada quando o pára-choques de admissão for libertado.

def lower_arm():
    arm_motor.spin_to_position(0, DEGREES)

def main():
    # Lower the Arm when the Intake Bumper is released
    intake_bumper.released(lower_arm)

# VR threads — Do not delete
vr_thread(main)

Óptico

objeto_detetado

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

Usage:
front_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 stop_intake():
    intake_motor.stop()

def main():
    # Stop the Intake Motor when the Optical Sensor detects a Disc
    front_optical.object_detected(stop_intake)
    intake_motor.spin(FORWARD)

# 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:
front_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 resume_intake():
    intake_motor.spin(FORWARD)

def main():
    # Restart the Intake Motor when the Optical Sensor no longer detects a Disc
    front_optical.object_lost(resume_intake)

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

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)

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 Motor da Catapulta 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

para-choque

pressionando

pressing returns a Boolean indicating whether the Intake Bumper is currently pressed.

• True - O batente de admissão está pressionado.

• False - O batente de admissão não está pressionado.

Usage:
intake_bumper.pressing()

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

def main():
    # Print whether the Intake Bumper is pressed
    brain.screen.print(intake_bumper.pressing())

# VR threads — Do not delete
vr_thread(main)

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

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

def main():
    # Print whether the Front Optical Sensor detects a nearby Disc
    brain.screen.print(front_optical.is_near_object())

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

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

def main():
    # Print the color detected by the Front Optical Sensor
    brain.screen.print(front_optical.color())

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

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

def main():
    # Print the Front Optical Sensor brightness
    brain.screen.print(front_optical.brightness())

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

Usage:
front_optical.hue()

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

def main():
    # Print the hue detected by the Front Optical Sensor
    brain.screen.print(front_optical.hue())

# VR threads — Do not delete
vr_thread(main)