Python específico para robôs#

Introdução#

O robô herói Fling inclui três opções de motor e o sensor de cor.

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

Consola – Imprima na consola e monitorize os valores.

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

  • Cor

    • color - Devolve a cor detectada pelo sensor de cor.

    • brightness - Devolve a quantidade de luz reflectida pelo objecto.

    • hue - Devolve a matiz detectada pelo sensor de cor.

    • is_near_object - Retorna se o Sensor de Cor deteta um objeto dentro do alcance.

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

Opcional. A unidade de distância: INCHES (padrão) ou MM (milímetros).

wait

Opcional. wait=True (padrão) faz com que o projeto aguarde até que o robô termine de se mover antes de executar a próxima linha de código. wait=False faz com que a próxima linha de código seja executada imediatamente.

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

# VR threads — Do not delete
vr_thread(main)

virar#

O comando turn o robô vire para a esquerda ou para a direita indefinidamente. O robô continuará a virar até receber outra ação, como conduzir ou parar.

Usage:
drivetrain.turn(direction)

Parâmetros

Descrição

direction

Direção para a qual o robô vira: LEFT ou RIGHT.

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

# VR threads — Do not delete
vr_thread(main)

virar_para#

O comando turn_for roda o robô para a esquerda ou para a direita num número específico de graus. A rotação é relativa à posição atual do robô. O projeto aguardará até que o robô termine de rodar antes de executar a próxima linha de código.

Usage:
drivetrain.turn_for(direction, angle, units, wait)

Parâmetros

Descrição

direction

Direção para a qual o robô vira: LEFT ou RIGHT.

angle

O número de graus que o robô roda. Pode ser um número inteiro integer ou decimal (float).

units

Opcional. Unidade de rotação: DEGREES (padrão).

wait

Opcional. wait=True (padrão) faz com que o projeto aguarde até que o robô termine de rodar antes de executar a próxima linha de código. wait=False faz com que a próxima linha de código seja executada imediatamente.

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

# VR threads — Do not delete
vr_thread(main)

virar_para_o_título#

A direção é a direção para a qual o robô está virado, medida em graus. turn_to_heading roda o robô de modo a ficar virado para uma direção específica de -359 a 359 graus. O robô irá rodar na direção mais curta para alcançar a direção desejada.

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

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

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

Parâmetros

Descrição

angle

A direção para a qual o robô deve estar virado, em graus. Pode ser um número inteiro integer ou um número de ponto flutuante (float), de -359 a 359.

units

Opcional. Unidade de rotação: DEGREES (padrão).

wait

Opcional. wait=True (padrão) faz com que o projeto aguarde até que o robô termine de rodar antes de executar a próxima linha de código. wait=False faz com que a próxima linha de código seja executada imediatamente.

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

# VR threads — Do not delete
vr_thread(main)

rodar_para_rotação#

turn_to_rotation roda o robô para uma rotação específica.

A rotação é o quanto o robô rodou, medida em graus. No início de um projeto, o valor de rotação é definido como 0 graus. A rotação também pode ser definida através do método set_rotation.

Os valores de rotação são absolutos. Isto significa que a direção da viragem depende da rotação atual do robô. Virar para a direita aumenta a rotação, e virar para a esquerda diminui a rotação.

Por exemplo, se o robô começar a 0 graus e rodar 720 graus, este irá virar para a direita duas vezes. Se depois rodar 360 graus, virará para a esquerda uma vez, porque 360 ​​é inferior a 720.

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

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

Parâmetros

Descrição

angle

O valor de rotação, em graus, para o qual o robô irá rodar. Pode ser um número inteiro integer ou decimal (float).

units

Opcional. Unidade de rotação: DEGREES (padrão).

wait

Opcional. wait=True (padrão) faz com que o projeto aguarde até que o robô termine de rodar antes de executar a próxima linha de código. wait=False faz com que a próxima linha de código seja executada imediatamente.

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

# VR threads — Do not delete
vr_thread(main)

parar#

stop interrompe o movimento do robô.

Usage:
drivetrain.stop()

Parâmetros

Descrição

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

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

# VR threads — Do not delete
vr_thread(main)

Mutantes#

definir_cabeçalho#

A direção é a direção para a qual o robô está virado, medida em graus. set_heading altera a direção atual do robô para um novo valor de direção.

Por exemplo, se o robô se virou para a direita, definir a direção para 0 graus faz com que essa posição virada para a direita se torne os novos 0 graus. De seguida, o robô pode rodar para outras posições com base nessa nova direção.

Usage:
drivetrain.set_heading(heading, units)

Parâmetros

Descrição

heading

O valor de direção, em graus, a definir para o robô. Pode ser um número inteiro integer ou decimal (float).

units

Opcional. Unidade de medida do cabeçalho: DEGREES (padrão).

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

# VR threads — Do not delete
vr_thread(main)

definir_rotação#

A rotação indica o quanto o robô rodou, medida em graus. No início de um projeto, o valor de rotação é definido como 0 graus. O comando set_rotation altera a rotação actual do robô para um novo valor.

Por exemplo, se o robô tiver dado duas voltas completas para a direita, o seu valor de rotação será de 720 graus. Definir a rotação para 0 graus irá repor essa rotação de 720 para 0 graus. De seguida, o robô poderá rodar para rotações baseadas nesse novo valor.

Usage:
drivetrain.set_rotation(rotation, units)

Parâmetros

Descrição

rotation

O valor de rotação, em graus, a definir para o robô. Pode ser um número inteiro integer ou decimal (float).

units

Opcional. Unidade de rotação: DEGREES (padrão).

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

# VR threads — Do not delete
vr_thread(main)

definir_tempo limite#

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

Usage:
drivetrain.set_timeout(value, units)

Parâmetros

Descrição

value

O tempo que o robô pode tentar para completar um movimento. Pode ser um número inteiro positivo integer ou decimal (float).

units

A unidade de tempo: SECONDS ou MSEC (milissegundos).

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

# VR threads — Do not delete
vr_thread(main)

definir_velocidade_de_acionamento#

O parâmetro set_drive_velocity ( set_drive_velocity define a velocidade de deslocação do robô. Uma percentagem mais elevada faz com que o robô se desloque mais rapidamente, enquanto uma percentagem mais baixa o faz deslocar-se mais lentamente.

Todos os projetos começam com o robô a deslocar-se a 50% da velocidade por defeito.

Nota: Uma velocidade mais elevada faz com que o robô se mova mais rapidamente, mas pode ser menos preciso. Uma velocidade mais baixa faz com que o robô se mova mais devagar, mas pode ser mais preciso.

Usage:
drivetrain.set_drive_velocity(velocity, units)

Parâmetros

Descrição

velocity

A velocidade de condução, de 0% a 100%. Pode ser um número inteiro integer ou decimal (float).

units

Opcional. Unidade de velocidade: PERCENT (padrão).

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

# VR threads — Do not delete
vr_thread(main)

definir_velocidade_de_viragem#

O parâmetro set_turn_velocity define a velocidade de rotação do robô. Uma percentagem mais elevada faz com que o robô gire mais rápido, enquanto uma percentagem mais baixa o faz girar mais devagar.

Todos os projetos começam com o robô a rodar a 50% da velocidade por defeito.

Nota: Uma velocidade mais elevada faz com que o robô gire mais rápido, mas pode ser menos preciso. Uma velocidade mais baixa faz com que o robô gire mais devagar, mas pode ser mais preciso.

Usage:
drivetrain.set_turn_velocity(velocity, units)

Parâmetros

Descrição

velocity

A velocidade de rotação, de 0% a 100%. Pode ser um número inteiro integer ou decimal (float).

units

Opcional. Unidade de velocidade: PERCENT (padrão).

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

# VR threads — Do not delete
vr_thread(main)

Getters#

cabeçalho#

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

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

Usage:
drivetrain.heading(units)

Parâmetros

Descrição

units

Opcional. Unidade de medida do cabeçalho: DEGREES (padrão).

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

# VR threads — Do not delete
vr_thread(main)

rotação#

A rotação indica o quanto o robô rodou, medida em graus. No início de um projeto, o valor de rotação é definido como 0 graus. O comando rotation devolve a rotação atual do robô.

Virar para a direita aumenta a rotação, e virar para a esquerda diminui a rotação. Por exemplo, duas voltas completas para a direita resultarão numa rotação de 720 graus.

Usage:
drivetrain.rotation(units)

Parâmetros

Descrição

units

Opcional. Unidade de rotação: DEGREES (padrão).

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

# VR threads — Do not delete
vr_thread(main)

está_concluído#

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

  • True — O robô terminou de se mover.

  • False — O robô ainda se está a mover.

Este método funciona em conjunto com os seguintes métodos Drivetrain que têm o parâmetro wait : drive_for, turn_for, turn_to_heading, e turn_to_rotation.

Usage:
drivetrain.is_done()

Parâmetros

Descrição

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

está_em_movimento#

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

  • True — O robô está em movimento.

  • False — O robô não se está a mover.

Usage:
drivetrain.is_moving()

Parâmetros

Descrição

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

velocidade#

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

Usage:
drivetrain.velocity(units)

Parâmetros

Descrição

units

Opcional. Unidade de velocidade: PERCENT (padrão).

Exemplo

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

Movimento#

O Fling utiliza o motor de entrada para puxar as bolas ou ejetá-las. Os motores da catapulta e da tensão do braço da catapulta lançam as bolas, sendo que a tensão altera a distância percorrida pelas bolas.

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

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 três objetos motores disponíveis pode ser utilizado com este método, como se mostra abaixo:

motor

Comando

intake_motor

intake_motor.spin(direction) — Motor de Admissão

catapult_motor

catapult_motor.spin(direction) — Motor da catapulta

catapult_tension_motor

catapult_tension_motor.spin(direction) — Motor de tensão da catapulta

Parâmetros

Descrição

direction

O sentido de rotação do motor depende do motor selecionado:

  • FORWARD — Roda o motor de entrada no sentido de entrada ou desloca o motor da catapulta selecionado para a frente.
  • REVERSE — Roda o motor de entrada no sentido de saída ou desloca o motor da catapulta selecionado para trás.

 
def main():
    # Spin the Intake Motor to collect a Ball
    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 três objetos motores disponíveis pode ser utilizado com este método, como se mostra abaixo:

motor

Comando

intake_motor

intake_motor.spin_for(direction, distance, units, wait=True) — Motor de Admissão

catapult_motor

catapult_motor.spin_for(direction, distance, units, wait=True) — Motor da catapulta

catapult_tension_motor

catapult_tension_motor.spin_for(direction, distance, units, wait=True) — Motor de tensão da catapulta

Parâmetros

Descrição

direction

O sentido de rotação do motor depende do motor seleccionado: FORWARD ou REVERSE.

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 a Ball with the Intake Motor
    intake_motor.spin_for(FORWARD, 360, 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 três objetos motores disponíveis pode ser utilizado com este método, como se mostra abaixo:

motor

Comando

intake_motor

intake_motor.spin_to_position(angle, units, wait=True) — Motor de Admissão

catapult_motor

catapult_motor.spin_to_position(angle, units, wait=True) — Motor da catapulta

catapult_tension_motor

catapult_tension_motor.spin_to_position(angle, units, wait=True) — Motor de tensão da catapulta

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():
    # Move the Catapult Motor to a launch position
    catapult_motor.spin_to_position(2600, DEGREES)

# VR threads — Do not delete
vr_thread(main)

motor de paragem#

stop impede que um motor gire.

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

motor

Comando

intake_motor

intake_motor.stop() — Motor de Admissão

catapult_motor

catapult_motor.stop() — Motor da catapulta

catapult_tension_motor

catapult_tension_motor.stop() — Motor de tensão da catapulta

Parâmetros

Descrição

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

 
def main():
    # Spin the Intake Motor, then stop it
    intake_motor.spin(FORWARD)
    wait(1, SECONDS)
    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 três objetos motores disponíveis pode ser utilizado com este método, como se mostra abaixo:

motor

Comando

intake_motor

intake_motor.set_position(position, units) — Motor de Admissão

catapult_motor

catapult_motor.set_position(position, units) — Motor da catapulta

catapult_tension_motor

catapult_tension_motor.set_position(position, units) — Motor de tensão da catapulta

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 Catapult Motor position, then return it to 0 degrees
    catapult_motor.set_position(2600, DEGREES)
    catapult_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 três objetos motores disponíveis pode ser utilizado com este método, como se mostra abaixo:

motor

Comando

intake_motor

intake_motor.set_velocity(velocity, units) — Motor de Admissão

catapult_motor

catapult_motor.set_velocity(velocity, units) — Motor da catapulta

catapult_tension_motor

catapult_tension_motor.set_velocity(velocity, units) — Motor de tensão da catapulta

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 Catapult Motor velocity before moving it
    catapult_motor.set_velocity(75, PERCENT)
    catapult_motor.spin_to_position(2600, 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 três objetos motores disponíveis pode ser utilizado com este método, como se mostra abaixo:

motor

Comando

intake_motor

intake_motor.set_timeout(value, units) — Motor de Admissão

catapult_motor

catapult_motor.set_timeout(value, units) — Motor da catapulta

catapult_tension_motor

catapult_tension_motor.set_timeout(value, units) — Motor de tensão da catapulta

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 Catapult Motor waits to reach its target
    catapult_motor.set_timeout(2, SECONDS)
    catapult_motor.spin_to_position(5000, 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 três objetos motores disponíveis pode ser utilizado com este método, como se mostra abaixo:

motor

Comando

intake_motor

intake_motor.is_done() — Motor de Admissão

catapult_motor

catapult_motor.is_done() — Motor da catapulta

catapult_tension_motor

catapult_tension_motor.is_done() — Motor de tensão da catapulta

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 três objetos motores disponíveis pode ser utilizado com este método, como se mostra abaixo:

motor

Comando

intake_motor

intake_motor.is_spinning() — Motor de Admissão

catapult_motor

catapult_motor.is_spinning() — Motor da catapulta

catapult_tension_motor

catapult_tension_motor.is_spinning() — Motor de tensão da catapulta

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 três objetos motores disponíveis pode ser utilizado com este método, como se mostra abaixo:

motor

Comando

intake_motor

intake_motor.position(units) — Motor de Admissão

catapult_motor

catapult_motor.position(units) — Motor da catapulta

catapult_tension_motor

catapult_tension_motor.position(units) — Motor de tensão da catapulta

Parâmetros

Descrição

units

A unidade para voltar à posição do motor em: DEGREES ou TURNS.

 
def main():
    # Print the current Catapult Motor position
    brain.screen.print(catapult_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 três objetos motores disponíveis pode ser utilizado com este método, como se mostra abaixo:

motor

Comando

intake_motor

intake_motor.velocity(units) — Motor de Admissão

catapult_motor

catapult_motor.velocity(units) — Motor da catapulta

catapult_tension_motor

catapult_tension_motor.velocity(units) — Motor de tensão da catapulta

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)

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

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
  • Arm Motor Group
    • 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
  • Intake Motor
    • 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
  • 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
  • Color Sensor
    • 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#

Cor#

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 de cor procura intervalos de tonalidade que correspondam à cor especificada. Para detetar intervalos de matiz específicos, consulte hue.

Usage:
color.color()

Parâmetros

Descrição

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

 
def main():
    # Print the color detected by the Color Sensor
    brain.screen.print(color.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 de cor. Uma percentagem mais baixa significa que menos luz é refletida de volta.

Usage:
color.brightness()

Parâmetros

Descrição

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

 
def main():
    # Print the Color Sensor brightness
    brain.screen.print(color.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.

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

Usage:
color.hue()

Parâmetros

Descrição

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

 
def main():
    # Print the hue detected by the Color Sensor
    brain.screen.print(color.hue())

# VR threads — Do not delete
vr_thread(main)

está_perto_do_objeto#

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

  • True – O sensor de cor deteta um objeto.

  • False – O sensor de cor não detetou qualquer objeto.

Usage:
color.is_near_object()

Parâmetros

Descrição

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

 
def main():
    # Print whether the Color Sensor detects an object nearby
    brain.screen.print(color.is_near_object())

# VR threads — Do not delete
vr_thread(main)
On this page