Objetivo da aula

• Entender como usar o ColorSensor no PyBricks (SPIKE Prime).
• Detectar cores (marcadores) e medir reflexão (seguir linha).
• Implementar um segue-linha com controle proporcional (P).
• Aprender a calibrar valores para maior repetibilidade.

Preparação

• Conecte o ColorSensor na porta C (ou outra, ajuste no código).
• Monte dois motores de tração nas portas A (esquerdo) e B (direito).
• Para seguir linha: use fita preta sobre base clara (ou vice-versa).

1) Visão geral do ColorSensor

Principais leituras no PyBricks:

• color() → retorna uma cor (ex.: Color.BLACK, Color.WHITE, Color.BLUE) ou None.
• reflection() → porcentagem de luz refletida (0–100). Base para seguir linha.
• ambient() → luminosidade do ambiente (0–100).
• rgb() → tupla (r, g, b) normalizada.

2) Detectando cores (marcadores)

Útil para pontos de referência na mesa (ex.: parar no verde, virar no azul).
Exemplo: avançar até detectar verde e então parar.

from pybricks.hubs import PrimeHub
from pybricks.pupdevices import Motor, ColorSensor
from pybricks.parameters import Port, Color, Stop
from pybricks.tools import wait

hub = PrimeHub()
mE, mD = Motor(Port.A), Motor(Port.B)
sensor = ColorSensor(Port.C)

mE.run(250); mD.run(250)

while True:
    cor = sensor.color()
    if cor == Color.GREEN:
        mE.stop(); mD.stop()
        hub.light.on(Color.GREEN)
        break
    wait(10)

3) Seguir linha por reflexão (básico por limiar)

O método mais simples é seguir a borda da linha (transição claro/escuro).

Passos:

1. Meça reflexão no claro e no escuro (preto).
2. Defina um alvo intermediário (ex.: média).
3. Se a leitura > alvo, corrija para um lado; se < alvo, corrija para o outro.

Calibração rápida

• Claro (~80–90), Escuro (~10–20) → alvo ≈ 50 (exemplo, meça no seu tapete).

alvo = 50        # ajuste após medir
vel_base = 220

while True:
    ref = sensor.reflection()
    if ref > alvo:
        mE.run(vel_base - 80); mD.run(vel_base + 80)
    else:
        mE.run(vel_base + 80); mD.run(vel_base - 80)
    wait(20)

4) Seguir linha com controle proporcional (P)

Para suavidade e precisão, use correção proporcional ao erro entre a leitura e o alvo:

erro = alvo - reflexão → correção = Kp * erro

alvo = 50
Kp = 3.0          # ganho: aumente se estiver “mole”, diminua se oscilar muito
vel_base = 200

while True:
    ref = sensor.reflection()
    erro = alvo - ref
    correcao = Kp * erro

    mE.run(vel_base - correcao)
    mD.run(vel_base + correcao)
    wait(15)

5) Usando DriveBase no segue-linha

Também é possível aplicar a correção na taxa de giro (turn rate) do DriveBase:

from pybricks.robotics import DriveBase

robot = DriveBase(mE, mD, 56, 120)

alvo, Kp, v = 50, 4.0, 180
while True:
    ref = sensor.reflection()
    erro = alvo - ref
    turn = Kp * erro          # em °/s de giro do robô
    robot.drive(v, turn)
    wait(15)

6) Paradas e eventos por cor

Combine segue-linha com marcadores de cor para decidir quando parar/virar.

alvo, Kp, v = 50, 4.0, 170
while True:
    if sensor.color() == Color.BLUE:
        robot.stop(Stop.HOLD)
        hub.light.on(Color.BLUE)
        break

    ref = sensor.reflection()
    turn = Kp * (alvo - ref)
    robot.drive(v, turn)
    wait(15)

7) Calibração prática (passo a passo)

1. Meça reflexão no claro e no escuro com o sensor a ~2–3 mm da superfície.
2. Defina o alvo como a média (ex.: claro 80, escuro 20 → alvo 50).
3. Comece com velocidade baixa (ex.: 150–200 mm/s ou 180°/s por motor).
4. Ajuste o Kp:
   • Se ziguezagueia demais → diminua Kp.
   • Se não corrige a tempo → aumente Kp.
5. Padronize altura/posição do sensor; pequenas diferenças mudam a leitura.

Erros comuns

• Sensor longe demais da linha → leitura fraca/instável.
• Alvo mal calibrado (muito próximo do claro ou do escuro) → correções exageradas.
• Luz ambiente forte alterando leituras → abaixe luz, aproxime sensor, use barreiras laterais.
• Velocidade alta em curva fechada → ultrapassa a borda; reduza a velocidade.

Atividades práticas

1. Crie um segue-linha básico por limiar e ajuste o alvo até funcionar com estabilidade.
2. Implemente o controle proporcional e compare a suavidade do trajeto.
3. Adicione uma parada por cor (ex.: azul) em um ponto da linha.
4. (Desafio) Faça uma função seguir_linha_ate_cor(alvo, kp, v, cor_alvo) reutilizável.