Índice:
2025 Autor: John Day | [email protected]. Última modificação: 2025-01-13 06:58
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:
- x3 pilhas AA - no meu caso, estou usando pilhas recarregáveis que têm uma voltagem geral mais baixa.
- Um robô GiggleBot da Dexter Industries para o micro: bit.
- 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.