Seguidor de linha GiggleBot usando Python: 5 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:37

Desta vez, estamos programando em MicroPython o Dexter Industries GiggleBot para seguir uma linha preta usando seu sensor de seguidor de linha embutido.

O GiggleBot deve ser emparelhado com um micro: bit BBC para que seja controlado de forma adequada.

Se este tutorial é muito avançado para você e programar o GiggleBot é demais por enquanto, você sempre pode seguir o tutorial inicial que mostra como o robô pode ser programado em MakeCode aqui. O tutorial vinculado o guiará pelos fundamentos básicos.

Etapa 1: Componentes necessários

Os seguintes componentes de hardware são necessários:

1. x3 pilhas AA - no meu caso, estou usando pilhas recarregáveis que têm uma voltagem geral mais baixa.
2. Um robô GiggleBot da Dexter Industries para o micro: bit.
3. Um micro BBC: bit.

Claro, você também precisa de um cabo micro USB para programar o BBC micro: bit - esse cabo geralmente vem com o pacote micro: bit da BBC ou você sempre pode usar um que seja usado para carregar smartphones (Android).

Obtenha o GiggleBot para o micro: um pouco aqui

Etapa 2: configurar as trilhas

Você terá que imprimir alguns ladrilhos e desenhar suas próprias pistas. Você pode usar nossos próprios ladrilhos para ter 100% de certeza de que está reproduzindo nossas condições. Ou se você se sentir aventureiro, você pode usar um pouco de fita preta e fazer o seu próprio. Aqui está o PDF para os tiles que usamos.

A trilha acima é composta pelo seguinte número de blocos diferentes:

• 12 ladrilhos do tipo # 1.
• 5 blocos do tipo # 2.
• 3 modelos de tipo de bloco # 5.
• 3 modelos do tipo de bloco # 6 - aqui, você acabará com um bloco extra.

Em seguida, imprima-os e corte-os. Tente colocá-los como na foto acima e lembre-se de que no lado superior direito da trilha, 2 blocos devem se sobrepor um ao outro - isso é esperado caso você esteja se perguntando se está fazendo algo errado.

Etapa 3: Configurando o ambiente

Para que você seja capaz de programar o BBC micro: bit em MicroPython, você deve configurar um editor para ele (o Editor Mu) e definir o GiggleBot MicroPython Runtime como seu tempo de execução. Para isso, você deve seguir as instruções desta página. A partir deste momento, a versão v0.4.0 do runtime é usada.

Etapa 4: Programando o GiggleBot

Antes de entrar no assunto, o tempo de execução GiggleBot MicroPython contém o tempo de execução clássico para o micro: bit da BBC e outras bibliotecas para oferecer suporte ao GiggleBot e outros sensores Dexter Industries.

Após configurá-lo, abra o seguinte script no editor Mu e clique em Flash. Isso irá mostrar o GiggleBot MicroPython Runtime e o script que você acabou de abrir no seu micro: bit da BBC. O script também é mostrado abaixo.

Assim que o processo de flashing estiver concluído, empilhe o micro BBC: bata no GiggleBot com os neopixels da placa voltados para frente, coloque-o na pista e ligue-o.

Observe que no script, o PID e outras 2 constantes (o ponto de ajuste de velocidade e as constantes de velocidade mínima) já estão configurados.

Observação: o script a seguir pode ter espaços em branco ausentes e isso parece ser devido a algum problema na exibição de Gist Gists do GitHub. Clique na essência para ir para a página do GitHub, onde você pode copiar e colar o código.

Seguidor de linha GiggleBot PID - Ajustado com NeoPixels

da importação de microbit *

da importação do gigglebot *

de utime import sleep_ms, ticks_us

import ustruct

# inicializar neopixels de GB

neo = init ()

# cronometragem

update_rate = 50

# ganhos / constantes (assumindo que a tensão da bateria está em torno de 4,0 volts)

Kp = 25,0

Ki = 0,5

Kd = 35,0

trigger_point = 0,3

min_speed_percent = 0.3

velocidade_base = 70

ponto de ajuste = 0,5

last_position = setpoint

integral = 0,0

run_neopixels = True

center_pixel = 5 # onde o pixel central do sorriso está localizado no GB

# turquesa = tupla (map (lambda x: int (x / 5), (64, 224, 208))) # cor a ser usada para desenhar o erro com os neopixels

# turquesa = (12, 44, 41) # que é exatamente o turquesa acima comentado acima deste

error_width_per_pixel = 0,5 / 3 # erro máximo dividido pelo número de segmentos entre cada neopixel

defupper_bound_linear_speed_reducer (abs_error, trigger_point, upper_bound, smallest_motor_power, higher_motor_power):

velocidade_ base global

if abs_error> = trigger_point:

# x0 = 0,0

# y0 = 0,0

# x1 = upper_bound - trigger_point

# y1 = 1.0

# x = abs_error - trigger_point

# y = y0 + (x - x0) * (y1 - y0) / (x1 - x0)

# igual a

y = (abs_error - trigger_point) / (upper_bound - trigger_point)

motor_power = base_speed * (smallest_motor_power + (1- y) * (maior_motor_power - menor_motor_power))

return motor_power

outro:

return base_speed * higher_motor_power

run = False

anterior_error = 0

whileTrue:

# se o botão a for pressionado, comece a seguir

if button_a.is_pressed ():

run = True

# mas se o botão b for pressionado, pare o seguidor de linha

if button_b.is_pressed ():

run = False

integral = 0,0

anterior_error = 0,0

pixels_off ()

Pare()

sleep_ms (500)

se executado isTrue:

# ler os sensores de linha

start_time = ticks_us ()

direita, esquerda = read_sensor (LINE_SENSOR, AMBOS)

# linha está à esquerda quando a posição <0,5

# linha está à direita quando a posição> 0,5

# linha está no meio quando posição = 0,5

# é uma média aritmética ponderada

Experimente:

posição = direita / flutuante (esquerda + direita)

exceptZeroDivisionError:

posição = 0,5

# o intervalo deve ser (0, 1) e não [0, 1]

se posição == 0: posição = 0,001

se posição == 1: posição = 0,999

# use um controlador PD

erro = posição - ponto de ajuste

integral + = erro

correção = Kp * erro + Ki * integral + Kd * (erro - erro_ anterior)

anterior_error = erro

# calcular as velocidades do motor

motor_speed = upper_bound_linear_speed_reducer (abs (erro), setpoint * trigger_point, setpoint, min_speed_percent, 1.0)

leftMotorSpeed = motor_speed + correção

rightMotorSpeed = motor_speed - correção

# acender os neopixels de acordo com o erro dado

se run_neopixels isTrueand total_counts% 3 == 0:

para i inb '\ x00 / x01 / x02 / x03 / x04 / x05 / x06 / x07 / x08':

neo = (0, 0, 0)

para i inb '\ x00 / x01 / x02 / x03':

ifabs (erro)> error_width_per_pixel * i:

se erro <0:

# neo [center_pixel + i] = turquesa

neo [center_pixel + i] = (12, 44, 41)

outro:

# neo [center_pixel - i] = turquesa

neo [center_pixel + i] = (12, 44, 41)

outro:

percent = 1- (error_width_per_pixel * i -abs (erro)) / error_width_per_pixel

# ilumina o pixel atual

se erro <0:

# neo [center_pixel + i] = tupla (map (lambda x: int (x * porcentagem), turquesa))

neo [center_pixel + i] = (int (64 * por cento / 5), int (224 * por cento / 5), int (208 * por cento / 5))

outro:

# neo [center_pixel - i] = tupla (map (lambda x: int (x * porcentagem), turquesa))

neo [center_pixel - i] = (int (64 * por cento / 5), int (224 * por cento / 5), int (208 * por cento / 5))

pausa

neo.show ()

Experimente:

# corte as velocidades do motor

se leftMotorSpeed> 100:

leftMotorSpeed = 100

rightMotorSpeed = rightMotorSpeed - leftMotorSpeed +100

se rightMotorSpeed> 100:

rightMotorSpeed = 100

leftMotorSpeed = leftMotorSpeed - rightMotorSpeed +100

se leftMotorSpeed <-100:

leftMotorSpeed = -100

se rightMotorSpeed <-100:

rightMotorSpeed = -100

# acionar os motores

set_speed (leftMotorSpeed, rightMotorSpeed)

dirigir()

# imprimir ((erro, velocidade_motor))

exceto:

# no caso de termos algum problema não corrigível

passar

# e manter a frequência do loop

end_time = ticks_us ()

delay_diff = (end_time - start_time) / 1000

if1000.0 / update_rate - delay_diff> 0:

dormir (1000.0 / update_rate - delay_diff)

visualizar rawgigglebot_tuned_line_follower.py hospedado com ❤ por GitHub

Etapa 5: Deixando funcionar

Existem 2 botões no micro BBC: bit: botão A e botão B:

• Pressionar o botão A define o GiggleBot para seguir a linha (se houver).
• Pressionar o botão B interrompe o GiggleBot e redefine tudo para que você possa usá-lo novamente.

É altamente recomendável não levantar o GiggleBot enquanto ele está seguindo uma linha e depois colocá-lo de volta porque o erro de cálculo pode se acumular e bagunçar totalmente a rota do robô. Se quiser levantá-lo, pressione o botão B e, ao colocá-lo de volta, pressione A novamente.