Python específico para robôs#
Introdução#
O robô robô Flex inclui um motor de garra, um motor de braço, um sensor de visão com inteligência artificial, um sensor de distância 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 26-27 Override 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 que velocidade deve conduzir.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– ID de classificação do objeto detetado.
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ô.
Distância
found_object– Retorna se o Sensor de Distância detetou um objeto dentro do alcance.object_distance– Retorna a distância entre o Sensor de Distância e o objecto detectado mais próximo.
GPS
x_position– Retorna a coordenada x actual do sensor GPS no campo.y_position– Retorna a coordenada y actual do sensor GPS no campo.heading– Retorna a direção para a qual o robô está atualmente virado com base no sensor GPS.
Os exemplos nesta página utilizam o Local de Partida C da lista de verificação pré-jogo 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 |
|---|---|
|
A direção em que o robô se move: |
def main():
# Raise the Arm, drive to the Goal, release the Pin
arm_motor.spin_for(FORWARD, 300, DEGREES)
drivetrain.drive(FORWARD)
wait(0.5, SECONDS)
drivetrain.stop()
claw_motor.spin_for(REVERSE, 180, DEGREES)
# 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 |
|---|---|
|
A direção em que o robô se move: |
|
A distância percorrida pelo robô. Pode ser um número inteiro |
|
Opcional. A unidade de distância: |
|
Opcional. |
def main():
# Raise the Arm, drive to the Goal, release the Pin
arm_motor.spin_for(FORWARD, 300, DEGREES)
drivetrain.drive_for(FORWARD, 10, INCHES)
claw_motor.spin_for(REVERSE, 180, DEGREES)
# 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 |
|---|---|
|
Direção para a qual o robô vira: |
def main():
# Score a Pin in a Neutral Goal
drivetrain.turn(LEFT)
wait(0.78, SECONDS)
drivetrain.stop()
arm_motor.spin_for(FORWARD, 800, DEGREES)
drivetrain.drive_for(FORWARD, 25, INCHES)
claw_motor.spin_for(REVERSE, 180, DEGREES)
# 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 |
|---|---|
|
Direção para a qual o robô vira: |
|
O número de graus que o robô roda. Pode ser um número inteiro |
|
Opcional. A unidade de ângulo: |
|
Opcional. |
def main():
# Score a Pin in a Neutral Goal
drivetrain.turn_for(LEFT, 110, DEGREES)
arm_motor.spin_for(FORWARD, 800, DEGREES)
drivetrain.drive_for(FORWARD, 25, INCHES)
claw_motor.spin_for(REVERSE, 180, 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 é de 0 graus.
Usage:
drivetrain.turn_to_heading(heading, units, wait)
Parâmetros |
Descrição |
|---|---|
|
A direção para a qual o robô deve estar virado varia entre -359 a 359 graus. |
|
Opcional. A unidade de ângulo: |
|
Opcional. |
def main():
# Score a Pin in a Neutral Goal
drivetrain.turn_to_heading(-110, DEGREES)
arm_motor.spin_for(FORWARD, 800, DEGREES)
drivetrain.drive_for(FORWARD, 25, INCHES)
claw_motor.spin_for(REVERSE, 180, 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 indica o quanto o robô rodou, medida em graus. No início de um projeto, o valor de rotação é definido como 0 graus. 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 até uma rotação de 720 graus, irá virar para a direita duas vezes. Se depois rodar até uma rotação de 360 graus, virará para a esquerda uma vez, porque 360 é inferior a 720.
Usage:
drivetrain.turn_to_rotation(rotation, units, wait)
Parâmetros |
Descrição |
|---|---|
|
O valor de rotação, em graus, para o qual o robô irá rodar. Pode ser um número inteiro |
|
Opcional. A unidade de ângulo: |
|
Opcional. |
def main():
# Score a Pin in a Neutral Goal
drivetrain.turn_to_rotation(-110, DEGREES)
arm_motor.spin_for(FORWARD, 800, DEGREES)
drivetrain.drive_for(FORWARD, 25, INCHES)
claw_motor.spin_for(REVERSE, 180, 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():
# Score a Pin in a Neutral Goal
drivetrain.turn(LEFT)
wait(0.78, SECONDS)
drivetrain.stop()
arm_motor.spin_for(FORWARD, 800, DEGREES)
drivetrain.drive_for(FORWARD, 25, INCHES)
claw_motor.spin_for(REVERSE, 180, DEGREES)
# 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 |
|---|---|
|
O valor da direção, em graus, a definir para o robô. |
|
Opcional. A unidade de ângulo: |
def main():
# Make facing the Neutral Goal the new heading
drivetrain.set_heading(110, 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. `set_rotation set_rotation alteram a rotação actual do robô para um novo valor.
Usage:
drivetrain.set_rotation(rotation, units)
Parâmetros |
Descrição |
|---|---|
|
O valor de rotação, em graus, a definir para o robô. Pode ser um número inteiro |
|
Opcional. A unidade de ângulo: |
def main():
# Make facing the Neutral Goal the new rotation
drivetrain.set_rotation(110, DEGREES)
drivetrain.turn_to_rotation(0, DEGREES)
# VR threads — Do not delete
vr_thread(main)
definir_tempo limite#
O parâmetro set_timeout set_timeout define quantos segundos 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(time, units)
Parâmetros |
Descrição |
|---|---|
|
O número de segundos que o robô pode tentar completar um movimento. Pode ser um número inteiro positivo |
|
Opcional. A unidade de tempo: |
def main():
# Turn to face the Neutral Goal
drivetrain.set_timeout(0.8, SECONDS)
drivetrain.turn_for(LEFT, 180, DEGREES)
# 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 |
|---|---|
|
A velocidade de condução, de 0% a 100%. Pode ser um número inteiro |
|
Opcional. Unidade de velocidade: |
def main():
# Score a Pin in a Neutral Goal
drivetrain.turn_for(LEFT, 110, DEGREES)
arm_motor.spin_for(FORWARD, 800, DEGREES)
drivetrain.set_drive_velocity(100, PERCENT)
drivetrain.drive_for(FORWARD, 25, INCHES)
claw_motor.spin_for(REVERSE, 180, DEGREES)
# 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 faz com que o robô gire mais devagar.
Todos os projetos começam com o robô a rodar a 50% da velocidade por defeito.
Nota: Uma velocidade mais elevada faz com que o robô gire mais rápido, mas pode ser menos preciso. Uma velocidade mais baixa faz com que o robô gire mais devagar, mas pode ser mais preciso.
Usage:
drivetrain.set_turn_velocity(velocity, units)
Parâmetros |
Descrição |
|---|---|
|
A velocidade de rotação, de 0% a 100%. Pode ser um número inteiro |
|
Opcional. Unidade de velocidade: |
def main():
# Turn to face the Neutral Goal faster
drivetrain.set_turn_velocity(100, PERCENT)
drivetrain.turn_for(LEFT, 110, 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 |
|---|---|
|
Opcional. Unidade de medida do cabeçalho: |
def main():
# Turn to the Goal, then show heading
drivetrain.turn_for(LEFT, 110, 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 |
|---|---|
|
Opcional. Unidade de rotação: |
def main():
# Spin to find a Pin, then show rotation
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. |
def main():
# Score a Pin in a Neutral Goal
drivetrain.turn_for(LEFT, 110, DEGREES)
arm_motor.spin_for(FORWARD, 800, DEGREES)
drivetrain.drive_for(FORWARD, 25, INCHES, wait=False)
wait(0.5, SECONDS)
while not drivetrain.is_done():
wait(5, MSEC)
claw_motor.spin_for(REVERSE, 180, DEGREES)
# VR threads — Do not delete
vr_thread(main)
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. |
def main():
# Raise the Arm once stopped near the Goal
drivetrain.turn_for(LEFT, 110, DEGREES)
drivetrain.drive_for(FORWARD, 25, INCHES, wait=False)
wait (0.5, SEC)
while drivetrain.is_moving():
wait(5, MSEC)
arm_motor.spin_for(FORWARD, 800, DEGREES)
# VR threads — Do not delete
vr_thread(main)
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 |
|---|---|
|
Opcional. Unidade de velocidade: |
def main():
# Show speed while driving to the Goal
drivetrain.drive_for(FORWARD, 150, MM)
brain.screen.print("Velocity: ")
brain.screen.print(drivetrain.velocity(PERCENT))
# VR threads — Do not delete
vr_thread(main)
Movimento#
O Flex utiliza o motor do braço para levantar e baixar o braço, e o motor da garra para abrir e fechar a garra.
Cada motor possui o seu próprio comportamento de condução. As descrições das direções explicam como cada direção movimenta o motor no Flex.
Ações#
rodar#
O comando spin faz com que o motor gire numa de duas direcções 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 |
|---|---|
|
|
|
|
Parâmetros |
Descrição |
|---|---|
|
Sentido de rotação do motor:
|
def main():
# Raise the Arm before driving toward a Pin
arm_motor.spin(FORWARD)
wait(1, SECONDS)
arm_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 |
|---|---|
|
|
|
|
Parâmetros |
Descrição |
|---|---|
|
Sentido de rotação do motor:
|
|
A distância a que o motor roda. |
|
Opcional. A unidade de distância: |
|
Opcional.
|
def main():
# Raise the Arm to carry the Pin to the Goal
arm_motor.spin_for(FORWARD, 800, 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 do Braço é definida para 0 graus. O Motor da Garra é a exceção — arranca nos 467 graus (completamente fechado). 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 |
|---|---|
|
|
|
|
Parâmetros |
Descrição |
|---|---|
|
O valor da posição para a qual o motor irá rodar. |
|
Opcional. A unidade de posição: |
|
Opcional.
|
def main():
# Raise the Arm, then release the Pin
arm_motor.spin_to_position(800, DEGREES)
claw_motor.spin_for(REVERSE, 180, DEGREES)
# 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 |
|---|---|
|
|
|
|
Parâmetros |
Descrição |
|---|---|
Este método não tem parâmetros. |
def main():
# Raise the Arm partway to hold the Pin
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 |
|---|---|
|
|
|
|
Parâmetros |
Descrição |
|---|---|
|
O valor de posição a definir para o motor. |
|
Opcional. A unidade de posição: |
def main():
# Reset encoder, raise Arm, place Pin
arm_motor.set_position(0, DEGREES)
arm_motor.spin_to_position(800, DEGREES)
claw_motor.spin_for(REVERSE, 180, 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 |
|---|---|
|
|
|
|
Parâmetros |
Descrição |
|---|---|
|
A velocidade de rotação, de 0% a 100%. Pode ser um número inteiro |
|
A unidade de velocidade: |
def main():
# Raise the Arm fast to release the Pin
arm_motor.set_velocity(100, PERCENT)
arm_motor.spin_for(FORWARD, 800, DEGREES)
claw_motor.spin_for(REVERSE, 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 |
|---|---|
|
|
|
|
Parâmetros |
Descrição |
|---|---|
|
O tempo que o motor pode tentar para completar um movimento. Pode ser um número inteiro positivo |
|
A unidade de tempo: |
def main():
# Score a Pin in a Neutral Goal
drivetrain.turn_for(LEFT, 110, DEGREES)
arm_motor.set_timeout(1, SECONDS)
arm_motor.spin_for(FORWARD, 1800, DEGREES)
drivetrain.drive_for(FORWARD, 25, INCHES)
claw_motor.spin_for(REVERSE, 180, 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 |
|---|---|
|
|
|
|
Parâmetros |
Descrição |
|---|---|
Este método não tem parâmetros. |
def main():
# Raise the Arm while driving to the Goal
arm_motor.spin_to_position(800, DEGREES, wait=False)
wait(0.1, SECONDS)
while not arm_motor.is_done():
drivetrain.drive(FORWARD)
wait(5, MSEC)
drivetrain.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 |
|---|---|
|
|
|
|
Parâmetros |
Descrição |
|---|---|
Este método não tem parâmetros. |
def main():
# Raise the Arm while driving to the Goal, then release the Pin
arm_motor.spin_to_position(800, DEGREES, wait=False)
wait(0.1, SECONDS)
while arm_motor.is_spinning():
drivetrain.drive_for(FORWARD, 25, MM)
claw_motor.spin_for(REVERSE, 180, DEGREES)
# 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 do braço é definida para 0 graus. O motor da garra é a exceção — arranca a 467 graus (completamente fechado). Se o motor rodar uma volta completa para a frente, a posição aumenta. Se o motor rodar no sentido oposto, a posição diminui.
Utilização:
Um dos dois objetos motorizados disponíveis pode ser utilizado com este método, como se mostra abaixo:
motor |
Comando |
|---|---|
|
|
|
|
Parâmetros |
Descrição |
|---|---|
|
A unidade para voltar à posição do motor em: |
def main():
# Raise the Arm, then release the Pin
while arm_motor.position(DEGREES) < 800:
arm_motor.spin(FORWARD)
wait(2, MSEC)
arm_motor.stop()
claw_motor.spin_for(REVERSE, 180, 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 |
|---|---|
|
|
|
|
Parâmetros |
Descrição |
|---|---|
|
A unidade de velocidade a devolver: |
def main():
# Show Arm Motor velocity while raising
arm_motor.set_velocity(100, PERCENT)
arm_motor.spin_to_position(800, DEGREES, wait=False)
wait(0.2, SECONDS)
brain.screen.print(arm_motor.velocity(PERCENT))
# 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 |
|---|---|
|
Filtra o conjunto de dados para incluir apenas os dados da assinatura fornecida. As subscrições disponíveis são:
|
def main():
# Raise the Arm, drive to the Goal, release the Pin
arm_motor.spin_for(FORWARD, 300, DEGREES)
drivetrain.drive_for(FORWARD, 10, INCHES)
claw_motor.spin_for(REVERSE, 180, DEGREES)
drivetrain.turn_for(LEFT, 70, DEGREES)
# Turn to face the Pin
drivetrain.set_turn_velocity(30, PERCENT)
while True:
ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
if ai_objects:
if ai_objects[0].centerX < 140:
drivetrain.turn(LEFT)
elif ai_objects[0].centerX > 180:
drivetrain.turn(RIGHT)
else:
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():
# Raise the Arm, drive to the Goal, release the Pin
arm_motor.spin_for(FORWARD, 300, DEGREES)
drivetrain.drive_for(FORWARD, 10, INCHES)
claw_motor.spin_for(REVERSE, 180, DEGREES)
drivetrain.turn_for(LEFT, 70, DEGREES)
# Approach the next Cup and Pin
drivetrain.set_drive_velocity(30, PERCENT)
while True:
ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
if ai_objects:
if ai_objects[0].width > 140:
drivetrain.stop()
break
else:
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():
# Raise the Arm, drive to the Goal, release the Pin
arm_motor.spin_for(FORWARD, 300, DEGREES)
drivetrain.drive_for(FORWARD, 10, INCHES)
claw_motor.spin_for(REVERSE, 180, DEGREES)
drivetrain.turn_for(LEFT, 70, DEGREES)
# Approach the next Cup and Pin
drivetrain.set_drive_velocity(30, PERCENT)
while True:
ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
if ai_objects:
if ai_objects[0].height > 200:
drivetrain.stop()
break
else:
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():
# Raise the Arm, drive to the Goal, release the Pin
arm_motor.spin_for(FORWARD, 300, DEGREES)
drivetrain.drive_for(FORWARD, 10, INCHES)
claw_motor.spin_for(REVERSE, 180, DEGREES)
drivetrain.turn_for(LEFT, 70, DEGREES)
# Turn and approach the next Cup and Pin
drivetrain.set_turn_velocity(30, PERCENT)
while True:
ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
if ai_objects:
if ai_objects[0].centerX < 140:
drivetrain.turn_for(LEFT, 5, DEGREES)
else:
drivetrain.drive_for(FORWARD, 25, INCHES)
break
# 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():
# Raise the Arm, drive to the Goal, release the Pin
arm_motor.spin_for(FORWARD, 300, DEGREES)
drivetrain.drive_for(FORWARD, 10, INCHES)
claw_motor.spin_for(REVERSE, 180, DEGREES)
drivetrain.turn_for(LEFT, 70, DEGREES)
# Approach the next Cup and Pin
drivetrain.set_drive_velocity(30, PERCENT)
while True:
ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
if ai_objects:
if ai_objects[0].centerY > 230:
drivetrain.stop()
break
else:
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():
# Raise the Arm, drive to the Goal, release the Pin
arm_motor.spin_for(FORWARD, 300, DEGREES)
drivetrain.drive_for(FORWARD, 10, INCHES)
claw_motor.spin_for(REVERSE, 180, DEGREES)
drivetrain.turn_for(LEFT, 70, DEGREES)
# Turn and approach the next Cup and Pin
drivetrain.set_turn_velocity(30, PERCENT)
while True:
ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
if ai_objects:
if ai_objects[0].originX < 100:
drivetrain.turn_for(LEFT, 5, DEGREES)
else:
drivetrain.drive_for(FORWARD, 25, INCHES)
break
# 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():
# Raise the Arm, drive to the Goal, release the Pin
arm_motor.spin_for(FORWARD, 300, DEGREES)
drivetrain.drive_for(FORWARD, 10, INCHES)
claw_motor.spin_for(REVERSE, 180, DEGREES)
drivetrain.turn_for(LEFT, 70, DEGREES)
# Approach the next Cup and Pin
drivetrain.set_drive_velocity(30, PERCENT)
while True:
ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
if ai_objects:
if ai_objects[0].originY > 140:
drivetrain.stop()
break
else:
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 |
|---|---|---|
Pino vermelhoAzul |
0 |
|
Pino AzulAmarelo |
1 |
|
Pino vermelho/amarelo |
2 |
|
Alfinete amarelo |
3 |
|
Taça |
4 |
|
def main():
# Raise the Arm, drive to the Goal, release the Pin
arm_motor.spin_for(FORWARD, 300, DEGREES)
drivetrain.drive_for(FORWARD, 10, INCHES)
claw_motor.spin_for(REVERSE, 180, DEGREES)
drivetrain.turn_for(LEFT, 70, DEGREES)
# Display the ID of the next closest object
while True:
ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
if ai_objects:
brain.screen.print(ai_objects[0].id)
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 |
|---|---|
|
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 |
|---|---|
|
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 number of loops
global loops
monitor_variable("loops")
# Turn in a full circle 3 times
for loops in range(12):
drivetrain.turn_for(RIGHT, 90, DEGREES)
# 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 |
|---|---|
|
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:
|
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#
Distância#
objeto_encontrado#
found_object retorna se o Sensor de Distância detetou um objeto a menos de 2000mm.
True— O sensor de distância detetou um objeto.False— O sensor de distância não detetou qualquer objeto.
Usage:
distance.found_object()
Parâmetros |
Descrição |
|---|---|
Este método não tem parâmetros. |
def main():
# Turn until something is detected, then release the Pin
drivetrain.turn(RIGHT)
while True:
wait(5, MSEC)
if distance.found_object():
drivetrain.stop()
break
arm_motor.spin_for(FORWARD, 300, DEGREES)
drivetrain.drive_for(FORWARD, 10, INCHES)
claw_motor.spin_for(REVERSE, 180, DEGREES)
# VR threads — Do not delete
vr_thread(main)
distância_do_objeto#
object_distance devolve a distância entre o sensor de distância e o objecto detectado mais próximo.
Usage:
distance.object_distance(units)
Parâmetros |
Descrição |
|---|---|
|
A unidade de distância: |
def main():
# Drive until 200 mm from the Goal, then release the Pin
while distance.object_distance(MM) > 200:
wait(5, MSEC)
drivetrain.drive(FORWARD)
drivetrain.stop()
arm_motor.spin_for(FORWARD, 300, DEGREES)
drivetrain.drive_for(FORWARD, 10, INCHES)
claw_motor.spin_for(REVERSE, 180, DEGREES)
# 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: |
def main():
# Raise the Arm, drive to the Goal, release the Pin
arm_motor.spin_for(FORWARD, 300, DEGREES)
drivetrain.drive(FORWARD)
while not gps.x_position(MM) > -1370:
wait(2, MSEC)
drivetrain.stop()
claw_motor.spin_for(REVERSE, 180, DEGREES)
# 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: |
def main():
# Raise the Arm, drive to the Goal, release the Pin
arm_motor.spin_for(FORWARD, 300, DEGREES)
drivetrain.drive(FORWARD)
while not gps.y_position(MM) < -450:
wait(2, MSEC)
drivetrain.stop()
claw_motor.spin_for(REVERSE, 180, DEGREES)
# 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():
# Raise the Arm, drive to the Goal, release the Pin
monitor_sensor("gps.heading")
arm_motor.spin_for(FORWARD, 300, DEGREES)
drivetrain.drive_for(FORWARD, 10, INCHES)
claw_motor.spin_for(REVERSE, 180, DEGREES)
# Turn left to face the Neutral Goal
drivetrain.set_turn_velocity(30, PERCENT)
drivetrain.turn(LEFT)
while not gps.heading() < 18:
wait(2, MSEC)
drivetrain.stop()
# VR threads — Do not delete
vr_thread(main)