Ajustando o seguidor de linha GiggleBot - Avançado: 7 etapas

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

Neste muito curto Instructables, você ajustará seu próprio GiggleBot para seguir uma linha preta. Neste outro tutorial, GiggleBot Line Follower, codificamos os valores de ajuste para funcionarem de acordo com esse cenário. Você pode querer fazer com que ele se comporte melhor obtendo outros ganhos.

Neste tutorial, mostramos 2 scripts que podem ser carregados em diferentes BBC micro: bits para que um deles seja colocado no GiggleBot e com o outro, os 2 botões são usados para percorrer um menu e sintonizar diferentes parâmetros. O envio desses parâmetros atualizados é feito via rádio.

Etapa 1: Componentes necessários

Você precisará do seguinte:

1. Um robô GiggleBot para o micro: bit.
2. x3 pilhas AA
3. x2 BBC micro: bits - um para o GiggleBot e o outro atuando como um controle remoto para os parâmetros de ajuste.
4. Uma bateria para BBC micro: bit - como a que vem no pacote BBC micro: bit.

Obtenha o Robô GiggleBot para o micro BBC: bit aqui

Etapa 2: Configurando as trilhas e o ambiente

Você também precisa construir suas trilhas (baixar, imprimir, cortar e colocar fita) e então configurar o ambiente (o IDE e o tempo de execução).

Como este tutorial está muito relacionado a este outro tutorial intitulado GiggleBot Line Follower, basta ir lá e seguir os passos 2 e 3 e depois voltar aqui.

Quanto ao IDE, você pode usar o editor Mu e para o tempo de execução, você precisa baixar o GiggleBot MicroPython Runtime. O runtime pode ser baixado de sua documentação aqui. Vá para o capítulo de introdução da documentação e siga as instruções sobre como configurar o ambiente. A partir deste momento, a versão v0.4.0 do runtime é usada.

Etapa 3: Configurando o GiggleBot

Antes de passar o tempo de execução para o GiggleBot, certifique-se de ter escolhido a velocidade desejada e a taxa de atualização para o GiggleBot: por padrão, a velocidade é definida como 100 (variável base_speed) e a taxa de atualização é definida como 70 (variável update_rate).

Dada a implementação atual, a taxa de atualização mais alta que pode ser alcançada é 70 e se run_neopixels for definido como True, então apenas 50 será alcançável. Então, de certa forma, você poderia dizer que a taxa de atualização padrão está bem no limite do que o micro: bit da BBC pode fazer.

Apenas para registro, o sensor de seguidor de linha pode retornar atualizações 100 vezes por segundo.

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.

Sintonizador de seguidor de linha GiggleBot PID (requer um controle remoto para sintonizá-lo) - xjfls23

da importação de microbit *

da importação do gigglebot *

de utime import sleep_ms, ticks_us

rádio de importação

import ustruct

# inicializar rádio e GB neopixels

radio.on ()

neo = init ()

# cronometragem

update_rate = 70

# valores de ganho padrão

Kp = 0,0

Ki = 0,0

Kd = 0,0

ponto de ajuste = 0,5

trigger_point = 0,0

min_speed_percent = 0.2

velocidade_base = 100

last_position = setpoint

integral = 0,0

run_neopixels = False

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

total_time = 0.0

total_counts = 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

display.scroll ('{} - {}'. formato (total_time, total_counts), delay = 100, wait = False)

total_time = 0.0

total_counts = 0

pixels_off ()

Pare()

sleep_ms (500)

se executado isTrue:

# ler os sensores de linha

start_time = ticks_us ()

# verifique se atualizamos os ganhos de Kp / Kd com um controle remoto

Experimente:

Kp, Ki, Kd, trigger_point, min_speed_percent = ustruct.unpack ('fffff', radio.receive_bytes ())

set_eyes ()

exceptTypeError:

passar

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

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 para mostrar em qual direção o GiggleBot deve ir

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] = (12, 44, 41)

outro:

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 (12 * por cento), int (44 * por cento), int (41 * por cento))

outro:

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

neo [center_pixel - i] = (int (12 * por cento), int (44 * por cento), int (41 * por cento))

pausa

neo.show ()

Experimente:

# prenda os motores

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

total_time + = delay_diff

total_counts + = 1

if1.0 / update_rate - delay_diff> 0:

dormir (1.0 / update_rate - delay_diff)

veja rawgigglebot_line_follower_tuner.py hospedado com ❤ por GitHub

Etapa 4: Configurando o Sintonizador (Remoto)

A próxima coisa que temos que fazer é atualizar o runtime + script para o segundo micro: bit da BBC. Este segundo micro: bit atuará como um controle remoto para o GiggleBot, que será usado para ajustar os seguintes parâmetros:

1. Kp = ganho proporcional para o controlador PID.
2. Ki = ganho integral para o controlador PID.
3. Kd = ganho derivativo para o controlador PID.
4. trigger_point = o ponto expresso em porcentagens entre as velocidades mínima e máxima do GiggleBot onde a velocidade começa a ser reduzida linearmente até atingir a velocidade mínima.
5. min_speed_percent = a velocidade mínima expressa em porcentagem da velocidade máxima.

As outras 2 variáveis restantes que podem ser ajustadas são codificadas diretamente no script que fica no GiggleBot: update_rate e base_speed que representa a velocidade máxima. Conforme descrito na documentação, a velocidade máxima que pode ser definida para o GiggleBot é 100, que também é o valor padrão para o nosso GiggleBot.

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.

Sintonizador de seguidor de linha PID remoto GiggleBot (requer a outra parte) - xjfls23

da importação de microbit *

do utime import sleep_ms

rádio de importação

import ustruct

# 1º elemento é o ganho de Kp

# 2º elemento é o ganho de Ki

# 3º elemento é o ganho de Kd

# 4º elemento é o ponto de gatilho para os motores reduzirem a velocidade (0 -> 1)

# 5º elemento é a velocidade mínima para motores, expressa em porcentagens (0 -> 1)

ganhos = [0,0, 0,0, 0,0, 1,0, 0,0]

stepSize = 0,1

# 0 e 1 para o primeiro elemento

# 2 e 3 para o 2º elemento

currentSetting = 0

defshowMenu ():

display.scroll ('{} - {}'. format (currentSetting, gain [int (currentSetting / 2)]), delay = 100, wait = False)

radio.on ()

showMenu ()

whileTrue:

atualizado = falso

if button_a.is_pressed ():

currentSetting = (currentSetting +1)% (2 * 5)

atualizado = verdadeiro

if button_b.is_pressed ():

se currentSetting% 2 == 0:

# aumenta o ganho quando currentSetting é 0 ou 2 ou..

ifint (currentSetting / 2) em [0, 2]:

ganhos [int (currentSetting / 2)] + = 10 * stepSize

outro:

ganhos [int (currentSetting / 2)] + = stepSize

outro:

# aumenta o ganho quando currentSetting é 1 ou 3 ou..

ifint (currentSetting / 2) em [0, 2]:

ganhos [int (currentSetting / 2)] - = 10 * stepSize

outro:

ganhos [int (currentSetting / 2)] - = stepSize

radio.send_bytes (ustruct.pack ('fffff', * ganhos))

atualizado = verdadeiro

se atualizado:

showMenu ()

sleep_ms (200)

visualizar rawgigglebot_line_follower_configurator.py hospedado com ❤ por GitHub

Etapa 5: Ajustando o GiggleBot

Coloque o GiggleBot na pista, ligue-o e deixe-o funcionar. Enquanto isso, você constantemente terá que colocá-lo de volta na pista e ajustar os ganhos / parâmetros com o outro micro: bit da BBC que você está segurando.

Para iniciar o GiggleBot, pressione o botão A no micro: bit BBC do GiggleBot e para interrompê-lo e, assim, redefinir seu estado, pressione o botão B.

No micro: bit remoto da BBC, pressionar o botão A levará você por todas as opções em seu menu e o botão B aumenta / diminui o valor correspondente. É como acertar o relógio no painel de um carro velho. As opções são as seguintes:

1. As opções 0-1 são para o ganho Kp.
2. 2-3 opções são para o ganho de Ki.
3. 4-5 opções são para o ganho Kd.
4. 6-7 opções são para definir o setpoint para o momento em que os motores começam a desacelerar.
5. 8-9 opções são para definir a velocidade mínima.

Lembre-se de que os números pares no menu são para aumentar os valores correspondentes e para os ímpares é exatamente o oposto.

Além disso, ao pressionar o botão B no BBC micro: bit do GiggleBot, você verá em sua tela feita em Neopixel o número de milissegundos decorridos desde a última reinicialização e o número de ciclos que o robô passou - com esses 2 você pode calcular a taxa de atualização do robô.

Por último e mais importante, eu vim com 2 afinações para o GiggleBot. Um deles é para quando os LEDs do Neopixel estiverem desligados e o outro para quando não estiver. Os LEDs Neopixel são usados para mostrar em qual direção o erro se acumulou.

1º conjunto de ajuste dos parâmetros (com LEDs NeoPixel desligados)

1. Kp = 32,0
2. Ki = 0,5
3. Kd = 80,0
4. trigger_setpoint = 0.3 (que é 30%)
5. min_speed_percent = 0.2 (que é 20%)
6. velocidade_base = 100 (também conhecida como velocidade máxima)
7. update_rate = 70 (executando a 70 Hz)

2º conjunto de ajuste dos parâmetros (com os LEDs NeoPixel acesos)

1. Kp = 25,0
2. Ki = 0,5
3. Kd = 35,0
4. trigger_setpoint = 0.3 (que é 30%)
5. min_speed_percent = 0.3 (que é 30%)
6. velocidade_base = 70 (também conhecida como velocidade máxima)
7. update_rate = 50 (executando a 50 Hz)
8. Além disso, a variável run_neopixels deve ser definida como True no script que é carregado no micro: bit BBC do GiggleBot. Isso fará com que os LEDs do NeoPixel pisquem de forma que indiquem em qual direção o erro se acumula.

Etapa 6: GiggleBot funcionando com os NeoPixels desligados

Este é um exemplo de execução do GiggleBot com os primeiros parâmetros de ajuste encontrados na etapa anterior. Este exemplo tem os LEDs NeoPixel desligados.

Etapa 7: GiggleBot executando com os neopixels ativados

Este é um exemplo de execução do GiggleBot com o segundo conjunto de parâmetros de ajuste encontrado na etapa 5. Este exemplo tem os LEDs NeoPixel ligados.

Observe como, neste exemplo, o GiggleBot tem mais dificuldade em seguir a linha - isso porque os LEDs Neopixel estão "comendo" o tempo da CPU do micro: bit da BBC. É por isso que tivemos que reduzir a taxa de atualização de 70 para 50.