Seguidor de línea GiggleBot usando Python: 5 pasos

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:42

Esta vez, estamos programando en MicroPython el GiggleBot de Dexter Industries para que siga una línea negra utilizando su sensor seguidor de línea incorporado.

El GiggleBot debe emparejarse con un micro: bit BBC para que se controle adecuadamente.

Si este tutorial es demasiado avanzado para usted y programar el GiggleBot es demasiado por ahora, siempre puede seguir el tutorial de inicio que le muestra cómo se puede programar el robot en MakeCode aquí. El tutorial vinculado lo guiará a través de los conceptos básicos.

Paso 1: componentes necesarios

Se requieren los siguientes componentes de hardware:

1. x3 baterías AA: en mi caso, estoy usando baterías recargables que tienen un voltaje más bajo en general.
2. Un robot GiggleBot de Dexter Industries para el micro: bit.
3. Un micro: bit de la BBC.

Por supuesto, también necesita un cable micro USB para programar el BBC micro: bit; este cable generalmente viene dentro del paquete BBC micro: bit o siempre puede usar uno que se use para cargar teléfonos inteligentes (Android).

¡Obtén el GiggleBot para el micro: bit aquí

Paso 2: configura las pistas

Tendrás que imprimir algunos mosaicos y diseñar tus propias pistas. Puede utilizar nuestros propios mosaicos para estar 100% seguro de que está replicando nuestras condiciones. O si te sientes aventurero, puedes usar cinta negra y hacer la tuya. Aquí está el PDF de los mosaicos que hemos utilizado.

La pista anterior se compone del siguiente número de mosaicos diferentes:

• 12 fichas de tipo # 1.
• 5 fichas de tipo # 2.
• 3 plantillas de tipo mosaico # 5.
• 3 plantillas del tipo de mosaico n. ° 6: aquí, terminará con un mosaico adicional.

A continuación, imprímalos y córtelos. Intente colocarlos como en la foto de arriba y tenga en cuenta que en el lado superior derecho de la pista, 2 mosaicos deben superponerse entre sí; esto es lo que se espera en caso de que se pregunte si está haciendo algo mal.

Paso 3: Configurar el entorno

Para que pueda programar BBC micro: bit en MicroPython, debe configurar un editor para él (el Editor Mu) y configurar GiggleBot MicroPython Runtime como su tiempo de ejecución. Para eso, debes seguir las instrucciones en esta página. A partir de este momento se utiliza la versión v0.4.0 del runtime.

Paso 4: Programación del GiggleBot

Antes de empezar, el tiempo de ejecución de GiggleBot MicroPython contiene el tiempo de ejecución clásico para BBC micro: bit y otras bibliotecas para admitir GiggleBot y otros sensores de Dexter Industries.

Después de configurarlo, abra el siguiente script en el editor Mu y haga clic en Flash. Esto mostrará el tiempo de ejecución de GiggleBot MicroPython y el script que acaba de abrir en su BBC micro: bit. El guión también se muestra a continuación.

Una vez finalizado el proceso de flasheo, apile el BBC micro: bit en el GiggleBot con los neopíxeles de la placa hacia adelante, colóquelo en la pista y enciéndalo.

Observe que en el script, el PID y otras 2 constantes (el punto de ajuste de velocidad y las constantes de velocidad mínima) ya están configuradas.

Nota: Es posible que falten espacios en blanco en el siguiente script y esto parece deberse a algún problema al mostrar GitHub Gists. Haga clic en la esencia para que lo lleve a su página de GitHub, donde puede copiar y pegar el código.

Seguidor de línea GiggleBot PID - Sintonizado con NeoPixels

desde la importación de microbit *

desde la importación de gigglebot *

desde utime import sleep_ms, ticks_us

importar ustruct

# inicializar neopíxeles de GB

neo = init ()

# momento

update_rate = 50

# ganancias / constantes (asumiendo que el voltaje de la batería es de alrededor de 4.0 voltios)

Kp = 25,0

Ki = 0,5

Kd = 35,0

trigger_point = 0.3

min_speed_percent = 0.3

velocidad_base = 70

punto de ajuste = 0.5

last_position = setpoint

integral = 0.0

run_neopixels = Verdadero

center_pixel = 5 # donde el píxel central de la sonrisa se encuentra en el GB

# turquesa = tupla (mapa (lambda x: int (x / 5), (64, 224, 208))) # color a usar para dibujar el error con los neopíxeles

# turquesa = (12, 44, 41) # que es exactamente el turquesa anterior comentado anteriormente.

error_width_per_pixel = 0.5 / 3 # error máximo dividido por el número de segmentos entre cada neopixel

defupper_bound_linear_speed_reducer (abs_error, trigger_point, upper_bound, pequeño_motor_power, mayor_motor_power):

velocidad_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 que

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

potencia_motor = velocidad_base * (potencia_motor_más pequeña + (1- y) * (potencia_motor_más alta - potencia_motor_más pequeña))

return motor_power

demás:

return velocidad_base * potencia_motor_máxima

ejecutar = Falso

error_anterior = 0

whileTrue:

# si se presiona el botón a, comience a seguir

si button_a.is_pressed ():

ejecutar = Verdadero

# pero si se presiona el botón b, detiene el seguidor de línea

si button_b.is_pressed ():

ejecutar = Falso

integral = 0.0

error_anterior = 0.0

pixels_off ()

parada()

sleep_ms (500)

si la ejecución es verdadera:

# leer los sensores de línea

hora_inicio = ticks_us ()

right, left = read_sensor (LINE_SENSOR, BOTH)

# la línea está a la izquierda cuando la posición <0.5

# línea está a la derecha cuando la posición> 0.5

# línea está en el medio cuando la posición = 0.5

# es una media aritmética ponderada

tratar:

posición = derecha / flotante (izquierda + derecha)

exceptZeroDivisionError:

posición = 0.5

# el rango tiene que ser (0, 1) y no [0, 1]

si posición == 0: posición = 0,001

si posición == 1: posición = 0,999

# use un controlador PD

error = posición - punto de ajuste

integral + = error

corrección = Kp * error + Ki * integral + Kd * (error - error_anterior)

previous_error = error

# calcular las velocidades del motor

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

leftMotorSpeed = motor_speed + corrección

rightMotorSpeed = motor_speed - corrección

# ilumina los neopíxeles según el error dado

si run_neopixels es Verdadero y total_counts% 3 == 0:

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

neo = (0, 0, 0)

para yo enb '\ x00 / x01 / x02 / x03':

ifabs (error)> error_width_per_pixel * i:

si error <0:

# neo [center_pixel + i] = turquesa

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

demás:

# neo [center_pixel - i] = turquesa

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

demás:

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

# ilumina el píxel actual

si error <0:

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

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

demás:

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

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

rotura

neo.show ()

tratar:

# recortar las velocidades del motor

si se deja Velocidad del motor> 100:

leftMotorSpeed = 100

rightMotorSpeed = rightMotorSpeed - leftMotorSpeed +100

si es correcto Velocidad del motor> 100:

rightMotorSpeed = 100

leftMotorSpeed = leftMotorSpeed - rightMotorSpeed +100

si leftMotorSpeed <-100:

leftMotorSpeed = -100

si rightMotorSpeed <-100:

rightMotorSpeed = -100

# accionar los motores

set_speed (leftMotorSpeed, rightMotorSpeed)

conducir()

# print ((error, motor_speed))

excepto:

# en caso de que tengamos algún problema que no se pueda solucionar

aprobar

# y mantener la frecuencia del bucle

end_time = ticks_us ()

delay_diff = (hora_final - hora_inicio) / 1000

if1000.0 / update_rate - delay_diff> 0:

dormir (1000.0 / update_rate - delay_diff)

ver rawgigglebot_tuned_line_follower.py alojado con ❤ por GitHub

Paso 5: dejarlo correr

Hay 2 botones en el micro: bit de BBC: botón A y botón B:

• Al presionar el botón A, el GiggleBot sigue la línea (si hay una).
• Al presionar el botón B, se detiene el GiggleBot y se restablece todo para que pueda usarlo nuevamente.

Se recomienda encarecidamente no levantar el GiggleBot mientras sigue una línea y luego volver a colocarlo porque el error que se está calculando podría acumularse y estropear totalmente la ruta del robot. Si desea levantarlo, presione el botón B y luego, cuando lo vuelva a colocar, presione A nuevamente.