Sintonización del seguidor de línea GiggleBot - Avanzado: 7 pasos

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

En estos Instructables muy cortos, sintonizarás tu propio GiggleBot para seguir una línea negra. En este otro tutorial GiggleBot Line Follower, codificamos los valores de ajuste para que funcionen de acuerdo con ese escenario. Es posible que desee que se comporte mejor con otros beneficios.

En este tutorial, le mostramos 2 scripts que se pueden cargar en diferentes micro: bits de BBC para que uno de ellos se coloque en el GiggleBot y con el otro, los 2 botones se usan para recorrer un menú y sintonizar diferentes parámetros. El envío de estos parámetros actualizados se realiza a través de la radio.

Paso 1: componentes necesarios

Necesitará lo siguiente:

1. Un robot GiggleBot para micro: bit.
2. x3 pilas AA
3. x2 BBC micro: bits: uno para el GiggleBot y el otro que actúa como control remoto para ajustar los parámetros.
4. Una batería para BBC micro: bit, como la que viene dentro del paquete BBC micro: bit.

Obtén el robot GiggleBot para BBC micro: bit aquí

Paso 2: Configuración de las pistas y el entorno

También tienes que crear tus pistas (descargar, imprimir, cortar y pegar mosaicos) y luego configurar el entorno (el IDE y el tiempo de ejecución).

Dado que este tutorial está muy relacionado con este otro tutorial titulado GiggleBot Line Follower, simplemente vaya allí y siga los pasos 2 y 3 y luego regrese aquí.

En cuanto al IDE, puede usar el editor Mu y para el tiempo de ejecución, debe descargar GiggleBot MicroPython Runtime. El tiempo de ejecución se puede descargar de su documentación aquí. Dirígete al capítulo de documentación de Introducción y sigue esas instrucciones sobre cómo configurar el entorno. A partir de este momento se utiliza la versión v0.4.0 del runtime.

Paso 3: Configuración de GiggleBot

Antes de actualizar el tiempo de ejecución al GiggleBot, asegúrese de haber elegido la velocidad deseada y la tasa de actualización para el GiggleBot: de forma predeterminada, la velocidad está configurada en 100 (variable base_speed) y la tasa de actualización está configurada en 70 (variable update_rate).

Dada la implementación actual, la tasa de actualización más alta que se puede lograr es 70 y si run_neopixels se establece en True, entonces solo 50 se puede lograr. Entonces, en cierto modo, se podría decir que la tasa de actualización predeterminada está al borde de lo que puede hacer el micro: bit de la BBC.

Solo para que conste, el sensor seguidor de línea puede devolver actualizaciones 100 veces por segundo.

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.

Sintonizador seguidor de línea GiggleBot PID (requiere un control remoto para sintonizarlo) - xjfls23

desde la importación de microbit *

desde la importación de gigglebot *

desde utime import sleep_ms, ticks_us

importar radio

importar ustruct

# inicializar neopíxeles de radio y GB

radio.on ()

neo = init ()

# momento

update_rate = 70

# valores de ganancia predeterminados

Kp = 0,0

Ki = 0.0

Kd = 0,0

punto de ajuste = 0.5

trigger_point = 0.0

min_speed_percent = 0.2

velocidad_base = 100

last_position = setpoint

integral = 0.0

run_neopixels = Falso

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

tiempo_total = 0.0

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

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

tiempo_total = 0.0

total_counts = 0

pixels_off ()

parada()

sleep_ms (500)

si la ejecución es verdadera:

# leer los sensores de línea

hora_inicio = ticks_us ()

# comprobar si hemos actualizado las ganancias de Kp / Kd con un control remoto

tratar:

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

set_eyes ()

exceptTypeError:

aprobar

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

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 para mostrar en qué dirección debe ir el GiggleBot

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

demás:

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

demás:

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

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

rotura

neo.show ()

tratar:

# recortar los motores

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

total_time + = delay_diff

total_counts + = 1

if1.0 / update_rate - delay_diff> 0:

dormir (1.0 / update_rate - delay_diff)

ver rawgigglebot_line_follower_tuner.py alojado con ❤ por GitHub

Paso 4: Configuración del sintonizador (remoto)

Lo siguiente que tenemos que hacer es flashear el script en tiempo de ejecución + en el segundo micro: bit de la BBC. Este segundo micro: bit actuará como un control remoto del GiggleBot, que se utilizará para ajustar los siguientes parámetros:

1. Kp = ganancia proporcional para el controlador PID.
2. Ki = ganancia integral para el controlador PID.
3. Kd = ganancia derivada para el controlador PID.
4. trigger_point = el punto expresado en porcentajes entre las velocidades mínima y máxima del GiggleBot donde la velocidad comienza a reducirse linealmente hasta que alcanza la velocidad mínima.
5. min_speed_percent = la velocidad mínima expresada en porcentaje de la velocidad máxima.

Las otras 2 variables restantes que se pueden ajustar están directamente codificadas en el script que se encuentra en el GiggleBot: update_rate y base_speed, que representa la velocidad máxima. Como se describe en la documentación, la velocidad máxima que se puede configurar para el GiggleBot es 100, que también es el valor predeterminado para nuestro GiggleBot.

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.

Sintonizador seguidor de línea PID remoto GiggleBot (requiere la otra parte) - xjfls23

desde la importación de microbit *

desde utime import sleep_ms

importar radio

importar ustruct

# El primer elemento es la ganancia de Kp

# El segundo elemento es la ganancia de Ki

# El tercer elemento es la ganancia Kd

# El cuarto elemento es el trigger_point para que los motores reduzcan la velocidad (0 -> 1)

# El quinto elemento es la velocidad mínima de los motores expresada en porcentajes (0 -> 1)

ganancias = [0.0, 0.0, 0.0, 1.0, 0.0]

stepSize = 0.1

# 0 y 1 para el 1er elemento

# 2 y 3 para el segundo elemento

currentSetting = 0

defshowMenu ():

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

radio.on ()

Muestrame el menu()

whileTrue:

actualizado = Falso

si button_a.is_pressed ():

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

actualizado = Verdadero

si button_b.is_pressed ():

if currentSetting% 2 == 0:

# aumentar la ganancia cuando currentSetting es 0 o 2 o..

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

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

demás:

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

demás:

# aumentar la ganancia cuando currentSetting es 1 o 3 o..

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

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

demás:

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

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

actualizado = Verdadero

si se actualiza:

Muestrame el menu()

sleep_ms (200)

ver rawgigglebot_line_follower_configurator.py alojado con ❤ por GitHub

Paso 5: afinando el GiggleBot

Coloque el GiggleBot en la pista, enciéndalo y déjelo funcionar. Mientras tanto, tendrás que volver a ponerlo en la pista constantemente y ajustar las ganancias / parámetros con el otro micro: bit de BBC que tienes en la mano.

Para iniciar el GiggleBot, presione el botón A en el BBC micro: bit del GiggleBot y para detenerlo y así restablecer su estado, presione el botón B.

En el control remoto BBC micro: bit, presionar el botón A lo llevará a través de cada opción en su menú y el botón B aumenta / disminuye el valor correspondiente. Es como poner el reloj en el tablero de un automóvil viejo. Las opciones son así:

1. Las opciones 0-1 son para la ganancia de Kp.
2. 2-3 opciones son para la ganancia de Ki.
3. 4-5 opciones son para la ganancia Kd.
4. 6-7 opciones son para establecer el punto de ajuste para el momento en que los motores comienzan a desacelerarse.
5. 8-9 opciones son para configurar la velocidad mínima.

Tenga en cuenta que los números pares del menú sirven para incrementar los valores correspondientes y para los impares es exactamente lo contrario.

Además, al presionar el botón B en el BBC micro: bit de GiggleBot, verá en su pantalla hecha con Neopixel el número de milisegundos transcurridos desde el último reinicio y el número de ciclos por los que ha pasado el robot; con estos 2 puede calcular la tasa de actualización del robot.

Por último y lo más importante, he creado 2 afinaciones para el GiggleBot. Uno de ellos es para cuando los LED de Neopixel están apagados y el otro es para cuando no es así. Los LED de Neopixel se utilizan para mostrar en qué dirección se ha acumulado el error.

1er conjunto de ajuste de los parámetros (con los LED de NeoPixel apagados)

1. Kp = 32,0
2. Ki = 0,5
3. Kd = 80,0
4. trigger_setpoint = 0.3 (que es 30%)
5. min_speed_percent = 0.2 (que es 20%)
6. base_speed = 100 (también conocida como velocidad máxima)
7. update_rate = 70 (corriendo a 70Hz)

Segundo conjunto de ajuste de los parámetros (con los LED de NeoPixel encendidos)

1. Kp = 25,0
2. Ki = 0,5
3. Kd = 35,0
4. trigger_setpoint = 0.3 (que es 30%)
5. min_speed_percent = 0.3 (que es 30%)
6. base_speed = 70 (también conocida como velocidad máxima)
7. update_rate = 50 (corriendo a 50Hz)
8. Además, la variable run_neopixels debe establecerse en True en el script que se carga en el micro: bit de la BBC de GiggleBot. Esto hará que los LED de NeoPixel parpadeen de tal manera que indiquen hacia qué dirección se acumula el error.

Paso 6: GiggleBot ejecutándose con los NeoPixels apagados

Este es un ejemplo de ejecución del GiggleBot con los primeros parámetros de ajuste encontrados en el paso anterior. Este ejemplo tiene los LED de NeoPixel apagados.

Paso 7: GiggleBot corriendo con los Neopixels encendidos

Este es un ejemplo de ejecución del GiggleBot con el segundo conjunto de parámetros de ajuste que se encuentran en el paso 5. Este ejemplo tiene los LED de NeoPixel encendidos.

Observe cómo en este ejemplo, el GiggleBot tiene más dificultades para seguir la línea, eso se debe a que los LED de Neopixel están "comiendo" el tiempo de CPU del micro: bit de la BBC. Por eso tuvimos que reducir la tasa de actualización de 70 a 50.