Bot de agarre de control remoto

Acerca de este proyecto

Hace unos meses, mi hijo me pidió que lo convirtiera en un robot de control remoto. Me dio una lista de lo que quería y la redujimos a una lista manejable :) Esto es lo que terminé construyendo para él ...

• Tome el protector del sensor UNO y V5 y encájelos.
• Coloque la placa UNO / Sensor unida en el soporte del clip dentro del centro del bot.
• Tome cinta adhesiva de doble cara y coloque el controlador del motor en la pared interior izquierda y el adaptador bluetooth en la pared derecha.

Para este proyecto puedes hacer tu propio chasis o elegir otro, la elección es tuya.

Paso 1:el software necesario

Cosas que necesitará descargar:

• El IDE de Arduino
• Python 2.7 (una instalación completa con tkinter)
• La biblioteca pySerial
• La biblioteca del controlador de motor L9110S adjunta .zip (vea los archivos en este paso)
• El código del robot a continuación o el .zip adjunto (consulte los archivos en este paso)
• La aplicación de control remoto Python (vea los archivos en este paso)

Paso 2:Lista de materiales del hardware

Las piezas que necesitará son las siguientes:

• Chasis de media pinta de Runt Rover o un reemplazo cerrado adecuado para 4x4
• Arduino Uno o placa similar con cable USB
• Escudo del sensor V5
• Controlador de motor L9110S (consigue un par, ya que son baratos)
• Servo MG995 u otro reemplazo adecuado x2
• Adaptador bluetooth HC-05 o HC-06 x1
• Placa de servo estándar B x1
• Soporte de 90 grados x1
• Corchete simple x2
• Servo hub ligero (525125 para Futaba) x1
• Kit de pinza estándar A x1
• Cables de puente de hembra a hembra
• 5 pilas AA recargables (NiMH) y cargador
• Cinta adhesiva de doble cara y pequeñas bridas
• Una batería 'AA' de 5 ranuras (si opta por la opción recargable AA)
• Paquete de baterías de iones de litio de 6v NiMH o de 7.4v y cargador
• 1.250 "6-32 tornillos x2
• .750 "8-32 espaciadores de nailon x2
• Tornillos de .500 "6-32 con tuercas x8
• .3125 "6-32 tornillos x8

Puede obtener muchas de las piezas de eBay u otros proveedores directamente como Sparkfun, Adafruit y ServoCity.

Una vez que haya comprado, recopilado y descargado todo, estará listo para comenzar con la compilación.

Paso 3:Montaje:el chasis

Primero ensamble el chasis siguiendo las instrucciones incluidas con el chasis o el video. Después de terminar deberías tener algo como la imagen. Cuando coloque la placa que sostiene el controlador en el bot, asegúrese de colocarlo en los orificios del medio. Esto dejará espacio en la parte delantera y trasera del bot.

NOTA:Antes de continuar, retire las 4 ruedas para no dañar los motores mientras coloca los otros componentes del bot.

Paso 4:Montaje de la pinza

Monte la pinza siguiendo las instrucciones proporcionadas en este video. Después de terminar, debería tener algo como la imagen.

Paso 5:Montaje de la pinza - Paso 1

Tome el soporte de 90 grados, el concentrador de servo liviano y cuatro (4) tornillos de .3125 "para este paso:

Tome el concentrador del servo y colóquelo en un lado del soporte y asegúrelos con los tornillos de .2125 "como se muestra en la imagen y déjelo a un lado. Coloque las tuercas en los dos tornillos más cortos y apriételos. Ahora cuente los dos soportes individuales, el 1.250 "tornillos y dos tornillos de .500" con tuercas, 2 espaciadores de nailon y la placa de servo B. Tome un solo soporte y colóquelo en el interior de la botella Half-pint y coloque los 2 tornillos de 1.259 "en los orificios izquierdos (desde el interior) y los tornillos de 2 .500 "en el lado derecho. Todas las cabezas de los tornillos estarán en el interior del bot como se muestra en la imagen. Ahora coloque el segundo soporte individual en los tornillos en el exterior del bot. A continuación, tome el espaciadores de nailon y colóquelos en el más largo (1.250 ") que sobresale y luego atornille la placa del servo en los tornillos largos Apriete los tornillos que van a la placa del servo con una llave hexagonal del tamaño adecuado o un destornillador si utilizó tornillos normales.

Utilice las imágenes como referencia según sea necesario.

Paso 6:Montaje de la pinza - Paso 2

• A continuación, tome el servo restante que tiene y colóquelo en el soporte del servo con el lomo hacia arriba. Asegúrelo con 4 de los tornillos de .3125 ".
• Luego tome el soporte de 90 grados con el servo hub y monte la pinza en él con los 4 tornillos de .500 "usando 2 de las 8-32 tuercas como espaciadores entre el soporte y la pinza como se muestra en la imagen. Asegure con otra tuerca en la parte superior de la pinza (debajo del soporte si gira los tornillos en el otro sentido)
• Ahora tome el ensamblaje de la pinza y colóquelo en el servo y use un tornillo de servo (de su paquete de servo) para mantenerlo en su lugar, asegurándolo firmemente.

Una vez que haya terminado, pase los dos cables del servo a través del orificio del soporte plano hacia el interior del robot.

Vea las imágenes para obtener más detalles y referencias.

Paso 7:Montaje de la electrónica

• Tome el protector del sensor UNO y V5 y encájelos.
• Coloque la placa UNO / Sensor unida en el soporte del clip dentro del centro del bot.
• Tome cinta adhesiva de doble cara y coloque el controlador del motor en la pared interior izquierda y el adaptador bluetooth en la pared derecha.

Paso 8:Cableado:los motores

• Pin A-1A en el controlador del motor al pin 5 en el protector del sensor
• Pin A-1B en el controlador del motor al pin 6 en el protector del sensor
• Pin B-1A en el controlador del motor al pin 3 en el protector del sensor
• Pin B-1B en el controlador del motor al pin 11 en el protector del sensor

Ahora, con el frente del robot alejado de usted, tome los cables del lado IZQUIERDO y ...

• Conecte los dos cables NEGROS de la izquierda al primer terminal de tornillo de salida para el Motor A
• Conecte los dos cables ROJOS de la izquierda al segundo terminal de tornillo de salida para el motor A

Tome los cables del lado DERECHO y -

• Conecte los dos cables NEGROS de la izquierda al primer terminal de tornillo de salida para el Motor B
• Conecte los dos cables ROJOS de la izquierda al segundo terminal de tornillo de salida para el motor B

Los Servos:

• Ahora conecte el cable del servo Y al pin de la línea 2 en el protector del sensor. El cable blanco o naranja es siempre el cable de señal.
• Ahora conecte el cable del servo X (pinza) a la línea de patilla 7 en el protector del sensor. El cable blanco o naranja es siempre el cable de señal.

Paso 9:cableado del módulo Bluetooth

• Adaptador Bluetooth Tx -> pin 0 del protector del sensor
• Adaptador Bluetooth Rx -> pin 1 del protector del sensor

Paso 10:agregando energía

Conecte los cables de alimentación del paquete de baterías de 5 'aa' (u otro paquete de 6v) al terminal de tornillo de alimentación del protector del sensor:

• Rojo a Vcc
• Negro a GND
• Luego, asegúrese de que el puente del protector del sensor V5 esté en su lugar en los pines del puente.
• Conecte el pin GND en el controlador L9110s a un pin GND en el protector del sensor.
• Conecte el cable positivo de la batería de 6v o 7.2v u otra batería que haya elegido para los motores al pin Vcc del controlador del motor L9110S.
• Conecte el cable negativo (GND) de la batería del motor a un pin GND en el blindaje del motor.

Paso 11:Configuración del módulo Bluetooth HC05 / HC06

Ahora deberá acceder a la configuración del dispositivo bluetooth en su PC desde el Panel de "Control" o "Sistemas" del SO o utilizar Google para ayudar.

Posible información de configuración de Bluetooth del sistema operativo:

• Windows
• Linux (uso blueman en Linux Mint, pero consulte su distribución para obtener más información)
• Mac

Deberá anotar el nombre del dispositivo de puerto serie o el número que se le asigna.

Paso 12:carga del código

Con el cableado revisado y vuelto a revisar , Es hora de cargar el código. Siga las instrucciones en el sitio de Arduino sobre cómo instalar el IDE de Arduino.

Una vez instalado el IDE, puede instalar la biblioteca del controlador de motor L9110. Haga esto descargando el archivo zip incluido en el PASO 1 llamado L9110Driver.zip y extrayéndolo a su carpeta de bibliotecas Arduino o siguiendo estas instrucciones sobre cómo agregar una biblioteca.

Ahora que se han instalado el IDE y la biblioteca de controladores de motor, cargue el código del robot en el IDE de Arduino desde el archivo zip que se encuentra en el PASO 1 llamado blue_t_slave.zip. Estos archivos también se incluyen en este paso.

Conecte su PC y Arduino con el cable USB. Ahora elija el tablero del menú Herramientas-> Tablero en el IDE, Uno para este proyecto (elija el tablero que tiene si es diferente de Uno) Ahora desde Herramientas-> menú Puerto, elija su puerto com. Una vez hecho esto, haga clic en el botón de carga. Si todo salió bien, se cargó el código; si no, consulte aquí para obtener ayuda sobre el IDE y problemas relacionados.

Paso 13:Ejecución de la aplicación de control Python

Para ejecutar la aplicación de control remoto Python, descargue el archivo zip de este paso y extráigalo en la ubicación desde donde desea ejecutarlo. A continuación, abra un shell de comandos (es decir, terminal, cmd.exe, etc.) y navegue hasta el directorio en el que extrajo el archivo. Ahora escriba: python rover.py desde la línea de comando y debería aparecer una ventana parecida a la de la imagen. De lo contrario, busque cualquier error de Python y corríjalo (es decir, bibliotecas faltantes, etc.). El sitio de Python puede ayudar si es necesario.

Una vez que la aplicación se esté ejecutando, debería estar listo.

Ahora, encienda el bot. Luego escriba el puerto de comunicaciones de su adaptador y haga clic en el botón "Conectar". Después de unos segundos, debería ver los otros controles habilitados y el botón de conexión deshabilitado. Esto significa que está conectado al robot. Si no puedes conectarte al adaptador bluetooth, ¡tendrás que usar la magia de Google para ayudarte!

La aplicación de control es fácil de usar y permite controles de mouse o teclado.

Los controles del teclado son:

• Las flechas están hacia adelante, hacia atrás, girar a la izquierda 90 grados, girar a la derecha 90 grados
• a - gire a la izquierda 45 grados
• s - gira a la derecha 45 grados
• h - detener (detener)
• y - establece el eje Y de la pinza
• u - abrir / cerrar la pinza
• c - pinza de inicio

Los comandos de avance y retroceso son constantes, es decir, mantienen al bot en movimiento después de la ejecución hasta que se envía una nueva dirección o un comando de detención.

Los giros de 90 y 45 grados son temporales, es decir, después de un cierto retraso, impiden que el robot se mueva.

Los controles deslizantes de la pinza no colocan automáticamente la pinza en el bot. Tienes que presionar el botón o tecla "Establecer" correspondiente para realizar la ejecución real del conjunto.

Los valores del control deslizante oscilan entre 0 y 180.

• Eje Y de la pinza:0 es completamente hacia arriba y 180 es completamente hacia abajo.
• Pinza abierta / cerrada:0 está completamente cerrada y 180 y completamente abierta.

Utilice el botón "Desconectar" para dejar de usar el programa. Esto enviará comandos para detener el bot y volver a colocar la pinza.

 #! / usr / bin / env python ## Para Linux, BSD o Mac OSX puede chmod + x en este script para hacer ejecutable ############# aplicación de control de Rover ## Escrito por Scott Beasley - 2015 # Gratis para usar o modificar. Disfruta. ############ import sysimport serialimport timefrom Tkinter import * import tkFontimport tkMessageBox # Crea la ventana para la aplicación de clase App (Frame):# Haz que la ventana def createWidgets (self):self.connected =False self.message =StringVar () # Haga una pequeña fuente para los botones de juego de pinzas. helv6 =tkFont.Font (family ='Helvetica', tamaño =6, peso ='normal') self.frame =Frame (self.master) self.frame.pack () self.f1 =Frame (self.frame) self .l1 =Etiqueta (self.f1, text ="Comm Port:") self.l1.pack (side =LEFT) self.comm_entry =Entrada (self.f1, bd =5, name ="comm_entry") self.comm_entry .pack (lado =IZQUIERDA) self.connectButton =Botón (self.f1, texto ="Conectar", comando =self.SerialConnect, nombre ="b_connect") self.connectButton.pack (lado =IZQUIERDA) self.disconnectButton =Botón (self.f1, texto ="Desconectar", comando =self.SerialDisconnect, nombre ="b_disconnect") self.disconnectButton.pack (lateral =DERECHA) self.f1.grid (fila =0, columna =0) self.f2 =LabelFrame (self.frame, bd =3, relieve ="groove", text ="Ground Control") self.g_vert_fm =Frame (self.f2) self.grip_vert =Scale (self.g_vert_fm, from_ =0, to =180) self.grip_vert.grid (fila =0, columna =0, rowspan =4, pegajoso =W) self.grip_vert_set =Botón (self.g_vert_fm, texto ="Establecer", comando =self.GripperY, nombre ="b_grip_vert_set", ancho =1, alto =2, fuente =helv6) self.grip_vert_set.grid (fila =5, columna =0, pegajoso =W) self.master.bind ("", self.GripperY) self. g_vert_fm.grid (fila =0, columna =0, rowspan =4, pegajoso =W) self.leftforwardButton =Button (self.f2, text ="\\", comando =self.TurnLeft45, name ="b_left_forward") self .leftforwardButton.grid (fila =0, columna =1) self.master.bind ("", self.TurnLeft45) self.leftButton =Botón (self.f2, text ="<", command =self.TurnLeft, name ="b_left") self.leftButton.grid (fila =1, columna =1) self.master.bind ("
 ", self.TurnLeft ) self.rightforwardButton =Botón (self.f2, text ="/", comando =self.TurnRight45, name ="b_right_forward") self.rightforwardButton.grid (fila =0, columna =3) self.master.bind (" 
  ", self.TurnRight45) self.haltButton =Botón (self.f2, text =" ¡Alto! ", comando =self.Halt, nombre =" b_halt ") self.haltButton .grid (fila =1, columna =2) self.master.bind ("  ", self.Halt) self.rightButton =Button (self.f2, text ="> ", command =self.TurnRight, name =" b_right ") self.rightButton.grid ( fila =1, columna =3) self.master.bind ("
 ", self.TurnRight) self.upButton =Botón (self.f2, text ="^", comando =self.Forward, name ="b_forward") self.upButton.grid (fila =0, columna =2) self.master.bind ("
 ", self.Forward) self.leftdownButton =Botón (self.f2, text ="/", comando =self.TurnRight45, nombre ="b_left_down") self.leftdownButton.grid (fila =2, columna =1) self.downButton =Botón (self. f2, text ="V", command =self.Reverse, name ="b_reverse") self.downButton.grid (fila =2, columna =2) self.master.bind ("
 ", self.Reverse) self.f2.grid (fila =1, columna =0, pady =25) self.rightdownButton =Button (self.f2, text ="\\", comando =self.TurnLeft45, name ="b_right_down") self.rightdownButton.grid (fila =2, columna =3) self.g_horz_fm =Marco (self.f2) self.grip_horz =Escala (s elf.g_horz_fm, from_ =0, to =180, orient =HORIZONTAL) self.grip_horz.grid (fila =0, columna =0, espacio de columnas =7, pegajoso =E) self.grip_horz_set =Botón (self.g_horz_fm, texto ="Conjunto", comando =self.GripperX, nombre ="b_grip_horz_set", ancho =1, alto =2, fuente =helv6) self.grip_horz_set.grid (fila =0, columna =8) self.master.bind (" ", self.GripperX) self.g_horz_fm.grid (fila =4, columna =0, columnaspan =7, pegajoso =E) self.master.bind ("  
  ", self.GripperHome) self.f3 =Marco (self.frame) self.l2 =Etiqueta (self.f3, text ="Última acción:") self.l2.pack (lado =IZQUIERDA) self.l3 =Etiqueta (self.f3, text ="", textvariable =self.message) self.l3.pack (lado =DERECHA) self.f3.grid (fila =3, columna =0, pady =8) # Establece el estado de los botones de control del bot. Habilitar cuando esté conectado, # Deshabilitado en caso contrario. def CtrlButtonsState (self, bstate):self.leftforwardButton.config (state =bstate) self.leftButton.config (state =bstate) self.rightforwardButton.config (state =bstate) self.rightButton.config (state =bstate) self. upButton.config (state =bstate) self.leftdownButton.config (state =bstate) self.downButton.config (state =bstate) self.rightdownButton.config (state =bstate) self.haltButton.config (state =bstate) self. desconectarButton.config (estado =bstate) self.grip_horz.config (estado =bstate) self.grip_vert.config (estado =bstate) self.grip_horz_set.config (estado =bstate) self.grip_vert_set.config (estado =bstate) # Establecer el estado de la entrada del puerto de comunicaciones. Habilitar cuando no está conectado, # Deshabilitado cuando el bot está conectado. def ConnCtrlsState (self, bstate):self.connectButton.config (state =bstate) self.comm_entry.config (state =bstate) # Conéctese al puerto de comunicación escrito en el campo de entrada de comunicación. def SerialConnect (self):intente:# Cambie la velocidad en baudios aquí si es diferente, luego 9600 self.ser =serial.Serial (self.comm_entry.get (), 9600) excepto IOError:tkMessageBox.showerror ("Puerto de comunicación no válido", " Comm port not found. ") Return self.ConnCtrlsState (DISABLED) self.CtrlButtonsState (NORMAL) self.message.set (" SerialConnect ") self.connected =True time.sleep (3) # Espera un poco para que suceda la conexión # Desconéctese del bot (cierre el puerto de comunicaciones). def SerialDisconnect (self):intente:# Envíe un comando de detención en caso de que el bot todavía se esté moviendo. self.send_cmd ('h', "¡Alto!") time.sleep (1) self.ser.close () excepto IOError:print "No se pudo cerrar el puerto ..." self.message.set ("SerialDisconnect") self .ConnCtrlsState (NORMAL) self.CtrlButtonsState (DISABLED) self.connected =False time.sleep (2) # Espera un poco para que ocurra la desconexión # Envía el comando al puerto de comunicación abierto def send_cmd (self, action, msg):if self.connected ==True:para val en acción:self.ser.write (val) self.ser.flush () self.message.set (msg) # Envía al bot un comando de giro a la izquierda. def TurnLeft (self, event =None):self.send_cmd ('a', "Left") # Envía al bot un comando para girar a la izquierda. def TurnLeft45 (self, event =None):self.send_cmd ('q', "Left45") # Envía al bot un comando de giro a la derecha. def TurnRight (self, event =None):self.send_cmd ('s', "Right") # Envía al bot un comando de giro a la derecha. def TurnRight45 (self, event =None):self.send_cmd ('e', "Right45") # Envía al bot un comando Forward. def Forward (self, event =None):self.send_cmd ('w', "Up") # Envía al bot un comando Reverse. def Reverse (self, event =None):self.send_cmd ('z', "Down") # Envía al bot un comando de detención. def Halt (self, event =None):self.send_cmd ('h', "¡Alto!") # Establecer la pinza (X). def GripperX (self, event =None):# Leer el control deslizante y enviar el valor al controlador del bot # Nota:0 está completamente cerrado y 180 completamente abierto grp_change =('>', chr (self. grip_horz.get ()), chr (255)) self.send_cmd (grp_change, "Gripper X") # Establezca el gripper Y. def GripperY (self, event =None):# Lea el control deslizante y envíe el valor al bot controller # Nota:0 es todo el camino hacia arriba y 180 es todo el camino hacia abajo grp_change =('^', chr (self.grip_vert.get ()), chr (255)) self.send_cmd (grp_change, "Gripper Y ") # Coloque la pinza en la posición" inicial ". def GripperHome (self, event =None):self.send_cmd (('c', chr (255)), "Gripper Home") def __init__ (self, master =None):Frame .__ init__ (self, master) self. pack () self.createWidgets () self.CtrlButtonsState (DISABLED) # Inicie la GUI (Tk), luego cambie el tamaño y el título de la aplicación windowdef main ():root =Tk () root.geometry ("450x350") root.wm_title ( "Rover Control Center (RCC)") app =App (master =root) app.mainloop () if __name__ =='__main__':main () 

 / * Móvil Bluetooth. Objetivo en la vida ... ¡Sigue tus órdenes enviadas mágicamente a través del aire! O desde USB :) Escrito por Scott Beasley - 2015 Gratis para usar o modificar. Enjoy. * // * Utiliza la biblioteca L9110S. Funciona con el puente en h L9110S. Descargue de https://github.com/jscottb/L9110Driver o clone el zip de https://github.com para eliminar el '-master' del nombre del archivo para agregar la biblioteca * / # include  #include  #define SERVO_Y 2 // Pinza pin Y servo # define SERVO_CLAW 7 // Pinza pin servo pinza # define pinAIN1 5 // define interfaz I1 # define pinAIN2 6 // define interfaz I2 # define pinBIN1 3 / / definir interfaz I3 # definir pinBIN2 11 // definir interfaz I4 // Definir velocidad # definir MAXFORWARDSPEED 225 // Velocidad máxima que queremos avanzar # definir MAXBACKWARDSPEED 225 // Velocidad máxima de retroceso # definir TOPSPEED 255 // Se usa para ayudar a encender mejor alfombras y superficies más ásperas .// Varios retrasos de tiempo utilizados para la conducción y el servo para interactuar con L9110_Motor motor_left (pinAIN1, pinAIN2); // Crear objeto de motor izquierdoL9110_Motor motor_right (pinBIN1, pinBIN2); // Crear objeto motor derechoServo grip_y_servo; // Crea un servoobjeto para la pinza Y axisServo grip_servo; // Cree un servoobjeto para la configuración de la garra del agarre () {// Cambie la velocidad en baudios aquí si es diferente a 9600 Serial.begin (9600); grip_y_servo.attach (SERVO_Y); // Adjuntar el servo SERVO_LR grip_y_servo.write (90); grip_servo.attach (SERVO_CLAW); // Adjuntar el servo SERVO_LR grip_servo.write (90); delay (500);} void loop () {byte command =0, val =0; if (Serial.available ()> 0) {// leer el byte de comando entrante command =Serial.read (); } cambiar (comando) {caso 'w':go_forward (); //Serial.println ("Avanzando"); descanso; caso 'z':go_backward (); //Serial.println ("Retrocediendo"); descanso; caso 'a':go_left (); retraso (TURNDELAY); detener (); //Serial.println ("Giro a la izquierda"); descanso; caso 's':go_right (); retraso (TURNDELAY); detener (); //Serial.println ("Giro a la derecha"); descanso; caso 'q':go_left (); retraso (TURNDELAY45); detener (); //Serial.println ("Giro a la izquierda"); descanso; caso 'e':go_right (); retraso (TURNDELAY45); detener (); //Serial.println ("Giro a la derecha"); descanso; caso 'h':halt (); //Serial.println ("Detención"); descanso; case '>':// El movimiento de la pinza X envía el valor establecido del servo val =Serial.read (); // Limitamos el valor a los límites de movimiento reales de la configuración grip_servo.write (constrain (val, 64, 179)); //Serial.println ("GripperX"); descanso; case '^':// El movimiento de la pinza Y envía el valor establecido del servo val =Serial.read (); // Limitamos el valor a los límites de movimiento reales de la configuración grip_y_servo.write (constrain (val, 53, 179)); //Serial.println ("GripperY"); descanso; case 'c':// Limitamos el valor a los límites de movimiento reales de la configuración grip_y_servo.write (90); grip_servo.write (90); //Serial.println ("GripperHome"); descanso; case 255:// Enviado después de todos los comandos de pinza Serial.flush (); descanso; } Serial.flush (); delay (125);} void go_forward () {//Serial.println ("Continuando ..."); // Acelera los motores a la velocidad. // Ayuda a girar en algunas superficies y vajilla y tara en el ramp_it del GM (MAXFORWARDSPEED, FORWARD, FORWARD); // Establezca toda la velocidad establecida solo en caso de que la última tina de la rampa no sea // completa. motor_left.setSpeed ​​(MAXFORWARDSPEED); motor_right.setSpeed ​​(MAXFORWARDSPEED); motor_left.run (ADELANTE | LIBERAR); motor_right.run (FORWARD | RELEASE);} void go_backward () {//Serial.println ("Yendo hacia atrás ..."); // Acelera los motores a la velocidad. // Ayuda a girar en algunas superficies y vajilla y tara en ramp_it del GM (MAXBACKWARDSPEED, BACKWARD, BACKWARD); // Establezca toda la velocidad establecida solo en caso de que la última tina de la rampa no sea // completa. motor_left.setSpeed ​​(MAXBACKWARDSPEED); motor_right.setSpeed ​​(MAXBACKWARDSPEED); motor_left.run (ATRÁS | LIBERAR); motor_right.run (BACKWARD | RELEASE);} void go_left () {//Serial.println ("Yendo a la izquierda ..."); // Acelera los motores a la velocidad. // Ayuda a girar en algunas superficies y vajilla y tara en ramp_it del GM (TOPSPEED, BACKWARD, FORWARD); // Establezca toda la velocidad establecida solo en caso de que la última tina de la rampa no sea // completa. motor_left.setSpeed ​​(TOPSPEED); motor_right.setSpeed ​​(TOPSPEED); motor_left.run (ATRÁS | LIBERAR); motor_right.run (ADELANTE | LIBERAR);} void go_right () {//Serial.println ("Yendo a la derecha ..."); // Acelera los motores a la velocidad. // Ayuda a girar en algunas superficies y vajilla y tara en el ramp_it del GM (TOPSPEED, FORWARD, BACKWARD); // Establezca toda la velocidad establecida solo en caso de que la última tina de la rampa no sea // completa. motor_left.setSpeed ​​(TOPSPEED); motor_right.setSpeed ​​(TOPSPEED); motor_left.run (ADELANTE | LIBERAR); motor_right.run (BACKWARD | RELEASE);} void halt () {//Serial.println ("¡Alto!"); // ramp_it (0, FRENO, FRENO); motor_left.setSpeed ​​(0); motor_right.setSpeed ​​(0); motor_left.run (BRAKE); motor_right.run (BRAKE);} void ramp_it (uint8_t velocidad, uint8_t lf_dir, uint8_t rt_dir) {uint8_t ramp_val =0, step_val =0; step_val =abs (velocidad / 4); if (! velocidad) step_val =-step_val; para (uint8_t i =0; i <4; i ++) {ramp_val + =step_val; motor_left.setSpeed ​​(ramp_val); motor_right.setSpeed ​​(ramp_val); motor_left.run (lf_dir | LIBERAR); motor_right.run (rt_dir | LIBERAR); retraso (25); }} 

Piezas y carcasas personalizadas

4wdgripperbt2.fzz

Esquemas

4wdgripperbt2.fzz