Mi motor de CC empezó a girar sólo cuando la velocidad estaba fijada en más de 100; si era menor, simplemente zumbaba. Tendrás que determinar experimentalmente la velocidad mínima de tu motor.

Para los motores conectados a M1 y M2, puede configurar la frecuencia: MOTOR12_64KHZ, MOTOR12_8KHZ, MOTOR12_2KHZ, MOTOR12_1KHZ. La velocidad de rotación más alta se logra a 64KHz, esta frecuencia será audible, menor frecuencia y velocidad a 1KHz pero también usa menos energía. Los motores 3 y 4 siempre funcionan a 1 KHz; los demás valores se ignoran. El valor predeterminado es 1 KHz en todas partes.

Después de esto, deberá realizar una prueba del motor. . Al comienzo del boceto, cambie el número del motor en una línea (o líneas) como:

El boceto hace girar los motores hacia adelante mientras el robot se mueve por un tiempo y luego hacia atrás. Mire con atención para ver si el motor gira en la dirección incorrecta y cambie la polaridad de la conexión si es necesario.

Conectamos el distanciómetro ultrasónico Módulo Ultrasónico HC-SR04. Configuración de pines:

• Disparo(T)
• Eco (R)

Tiempo dedicado por un telémetro ultrasónico a las mediciones (determinado experimentalmente):

• máximo 240 ms si la distancia es demasiado grande (fuera de rango)
• mínimo 1 ms si la distancia es demasiado corta
• una distancia de 1,5 m se determina en aproximadamente 10 ms

El sensor ultrasónico del telémetro, por su naturaleza física, y no porque China, en algunos casos determina mal la distancia a un obstáculo:

• si el obstáculo tiene una forma compleja, entonces el ultrasonido se refleja en diferentes ángulos y el sensor se equivoca,
• El ultrasonido es perfectamente absorbido (es decir, no reflejado) por muebles tapizados o juguetes, y el sensor cree que no hay nada delante.

En otras palabras, lo ideal para un telémetro ultrasónico sería fantástico si todos los obstáculos tuvieran la forma de un plano sólido perpendicular a la dirección de la radiación ultrasónica.

Algunos problemas se pueden solucionar utilizando un sensor de distancia por infrarrojos. Pero tampoco es perfecto:

• alcance máximo pequeño en comparación con el ultrasonido: 0,3-0,8 m frente a 4 m
• Distancia mínima grande en comparación con los ultrasonidos: 10 cm frente a 2 cm
• Dependencia de la sensibilidad del sensor de la iluminación general.

Aunque si estos telémetros se instalaran por parejas, su rendimiento aumentaría notablemente.

Conecte Bluetooth HC-05

Como podemos ver en la hoja de datos, los pines principales del HC-05 “desnudo”:

• Transmisión TX (pin 1)
• Recepción RX (pin 2)
• Fuente de alimentación de 3,3 V (pin 12) 3,3 V
• GND (pin 13) tierra
• Indicador de modo PIO8 (pin 31)
• Estado de conexión PIO9 (pin 32), si se establece la conexión, la salida será alta
• PIO11 (pin 34) para habilitar el modo de comando AT

Nuestro módulo está soldado a la placa base/conexión, que ya tiene un divisor de voltaje, por lo que su rango de voltaje de funcionamiento es de 3,3 V a 6 V.

Conectamos nuestro conjunto de módulo Bluetooth:

• Arduino (TX) - (RX) HC-05
• Arduino (RX) - (TX) HC-05
• Arduino (+5V) - (VCC)Bluetooth
• Arduino (GND) - (GND) Bluetooth
• Los pines LED y KEY no se utilizan

Después de que se suministra energía al módulo Bluetooth HC-05, el LED debe parpadear, lo que significa que Bluetooth está funcionando.

Encendemos el bluetooth en el móvil, buscamos el dispositivo con el nombre HC-05 y nos conectamos, la contraseña es 1234.

Para realizar pruebas, cargue un boceto simple en Arduino:

En un teléfono Android instalamos Terminal Bluetooth. Nos conectamos al dispositivo HC-05 y miramos las líneas con un contador creciente en la pantalla del teléfono.

Para que el módulo acepte comandos AT, se debe poner en el modo apropiado; para hacer esto, debe configurar el pin KEY (PIO11) en la lógica 1. En algunas placas base/de ruptura, en lugar del pin KEY, hay un pin EN (HABILITAR), que puede estar soldado o no a un pin en el propio chip. Esto sólo se aplica a los chips HC05. Es solo que mi pin EN del tablero no está soldado en ninguna parte. Por lo tanto, se puede soldar con un cable separado al pin KEY(PIO11) del chip. O, durante la operación, para cambiar el HC05 al modo de comando AT, cortocircuite el pin del chip KEY(PIO11) al pin de alimentación Vcc durante un par de segundos. Para HC06, el pin KEY no es necesario.

Software

Nota. Cada vez que cargue un programa en el Arduino, asegúrese de que el módulo Bluetooth no esté conectado al Arduino. Esto causará problemas para completar el boceto. Simplemente desconecte la alimentación del módulo Bluetooth o los cables que conectan el Arduino y los pines RX, TX del módulo.

Al comienzo del boceto, cambie los números de motor en líneas como:

Si reemplazas la línea

entonces se activará el modo de depuración.

En el modo de depuración, el robot RoboCar4W en realidad no conducirá ni hará girar sus ruedas. En su lugar, active el monitor del puerto serie y vea cómo “conduce” virtualmente. En lugar de avanzar realmente, la cadena "Adelante" se escribirá en el monitor del puerto serie, en lugar de retroceder con un giro a la izquierda - "Voltear hacia atrás L (eft)", etc. El sensor de distancia ultrasónico tampoco hace nada, sino que las distancias a los obstáculos se generan de forma programática y aleatoria.

Hablemos de cómo puedes usar Arduino para crear un robot que se equilibre como un Segway.

Segway del inglés. Segway es un vehículo de dos ruedas equipado con propulsión eléctrica. También se les llama hoverboards o patinetes eléctricos.

¿Alguna vez te has preguntado cómo funciona un Segway? En este tutorial intentaremos mostrarte cómo hacer un robot Arduino que se equilibre como un Segway.

Para equilibrar el robot, los motores deben resistir la caída del robot. Esta acción requiere retroalimentación y elementos correctivos. Elemento de retroalimentación: que proporciona aceleración y rotación en los tres ejes (). Arduino usa esto para conocer la orientación actual del robot. El elemento correctivo es la combinación de motor y rueda.

El resultado final debería ser algo como esto:

diagrama de robot

Módulo controlador de motor L298N:

Motorreductor CC con rueda:

Un robot que se autoequilibra es esencialmente un péndulo invertido. Puede estar mejor equilibrado si el centro de masa está más alto en relación con los ejes de las ruedas. Un centro de masa más alto significa un mayor momento de inercia de la masa, lo que corresponde a una menor aceleración angular (caída más lenta). Por eso ponemos la batería encima. Sin embargo, la altura del robot se eligió en función de la disponibilidad de materiales :)

La versión completa del robot autoequilibrado se puede ver en la figura de arriba. En la parte superior hay seis baterías de Ni-Cd para alimentar la PCB. Entre los motores se utiliza una batería de 9 voltios como controlador del motor.

Teoría

En teoría del control, mantener alguna variable (en este caso la posición del robot) requiere un controlador especial llamado PID (derivado integral proporcional). Cada uno de estos parámetros tiene una "ganancia", normalmente denominada Kp, Ki y Kd. El PID proporciona corrección entre el valor deseado (o entrada) y el valor real (o salida). La diferencia entre entrada y salida se llama "error".

El controlador PID reduce el error al valor más pequeño posible ajustando continuamente la salida. En nuestro robot autoequilibrado Arduino, la entrada (que es la inclinación deseada en grados) se establece mediante software. El MPU6050 lee la inclinación actual del robot y la envía al algoritmo PID, que realiza cálculos para controlar el motor y mantener el robot en posición vertical.

El PID requiere que los valores de Kp, Ki y Kd se ajusten a valores óptimos. Los ingenieros utilizan software como MATLAB para calcular automáticamente estos valores. Desafortunadamente, no podemos usar MATLAB en nuestro caso porque complicará aún más el proyecto. En cambio, ajustaremos los valores de PID. He aquí cómo hacerlo:

1. Haga que Kp, Ki y Kd sean iguales a cero.
2. Ajustar Kp. Un Kp demasiado pequeño provocará la caída del robot porque la corrección no es suficiente. Demasiado Kp hace que el robot se mueva frenéticamente de un lado a otro. Un buen Kp hará que el robot se mueva bastante hacia adelante y hacia atrás (o oscile un poco).
3. Una vez establecido Kp, ajuste Kd. Un buen valor de Kd reducirá las oscilaciones hasta que el robot se vuelva casi estable. Además, el Kd correcto sujetará el robot incluso si lo empujan.
4. Finalmente, instale Ki. Cuando se enciende, el robot oscilará incluso si se configuran Kp y Kd, pero se estabilizará con el tiempo. El valor Ki correcto reducirá el tiempo necesario para estabilizar el robot.

El comportamiento del robot se puede ver en el siguiente vídeo:

Código Arduino para robot autoequilibrado

Necesitábamos cuatro bibliotecas externas para crear nuestro robot. La biblioteca PID simplifica el cálculo de los valores P, I y D. La biblioteca LMotorController se utiliza para controlar dos motores con el módulo L298N. La biblioteca I2Cdev y la biblioteca MPU6050_6_Axis_MotionApps20 están diseñadas para leer datos del MPU6050. Puede descargar el código, incluidas las bibliotecas, en este repositorio.

#incluir #incluir #incluye "I2Cdev.h" #incluye "MPU6050_6Axis_MotionApps20.h" #if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE #incluye "Wire.h" #endif #define MIN_ABS_SPEED 20 MPU6050 mpu; // control/estado de MPU vars bool dmpReady = false; // se establece en verdadero si el inicio de DMP fue exitoso uint8_t mpuIntStatus; // mantiene el byte de estado de interrupción real de la MPU uint8_t devStatus; // devuelve el estado después de cada operación del dispositivo (0 = éxito, !0 = error) uint16_t paqueteSize; // tamaño de paquete DMP esperado (el valor predeterminado es 42 bytes) uint16_t fifoCount; // recuento de todos los bytes actualmente en FIFO uint8_t fifoBuffer; // buffer de almacenamiento FIFO // orientación/movimiento vars Quaternion q; // contenedor de cuaterniones VectorFloat gravedad; // vector de gravedad float ypr; //contenedor de guiñada/cabeceo/giro y vector de gravedad //PID double originalSetpoint = 173; punto de ajuste doble = punto de ajuste original; doble movimientoAngleOffset = 0,1; doble entrada, salida; //ajusta estos valores para que se ajusten a tu propio diseño double Kp = 50; doble Kd = 1,4; doble Ki = 60; PID pid(&entrada, &salida, &punto de ajuste, Kp, Ki, Kd, ​​DIRECTO); doble motorSpeedFactorLeft = 0,6; doble motorSpeedFactorRight = 0,5; //CONTROLADOR DEL MOTOR int ENA = 5; entero EN1 = 6; entero EN2 = 7; entero EN3 = 8; entero EN4 = 9; int ENB = 10; LMotorController motorController(ENA, IN1, IN2, ENB, IN3, IN4, motorSpeedFactorLeft, motorSpeedFactorRight); volátil bool mpuInterrupt = falso; // indica si el pin de interrupción de MPU se ha elevado void dmpDataReady() ( mpuInterrupt = true; ) void setup() ( // unirse al bus I2C (la biblioteca I2Cdev no hace esto automáticamente) #if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE Wire.begin( ); TWBR = 24; // Reloj I2C de 400 kHz (200 kHz si la CPU es de 8 MHz) #elif I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_FASTWIRE Fastwire::setup(400, true); , escalado para sensibilidad mínima mpu.setXGyroOffset(220); mpu.setYGyroOffset(-85); mpu.setZAccelOffset(1788); asegúrese de que funcionó (devuelve 0 si es así) if (devStatus == 0) ( // encienda el DMP, ahora que está listo mpu.setDMPEnabled(true); // habilite la detección de interrupciones de ArduinoInterrupt(0, dmpDataReady, RISING); mpuIntStatus = mpu.getIntStatus(); // configure nuestro indicador DMP Ready para que el principal La función loop() sabe que está bien usarla dmpReady = true; // obtiene el tamaño de paquete DMP esperado para compararlo más tarde. packageSize = mpu.dmpGetFIFOPacketSize(); //configurar PID pid.SetMode(AUTOMATIC); pid.SetSampleTime(10); pido. Establecer límites de salida (-255, 255); ) else ( // ¡ERROR! // 1 = falló la carga de memoria inicial // 2 = fallaron las actualizaciones de configuración de DMP // (si se va a romper, generalmente el código será 1) Serial.print(F("Inicialización de DMP falló (código ")); Serial.print(devStatus); Serial.println(F()")); void loop() ( // si la programación falló, no intente hacer nada if (!dmpReady ) return // espera la interrupción de la MPU o paquetes adicionales disponibles mientras (!mpuInterrupt && fifoCount< packetSize) { //no mpu data - performing PID calculations and output to motors pid.Compute(); motorController.move(output, MIN_ABS_SPEED); } // reset interrupt flag and get INT_STATUS byte mpuInterrupt = false; mpuIntStatus = mpu.getIntStatus(); // get current FIFO count fifoCount = mpu.getFIFOCount(); // check for overflow (this should never happen unless our code is too inefficient) if ((mpuIntStatus & 0x10) || fifoCount == 1024) { // reset so we can continue cleanly mpu.resetFIFO(); Serial.println(F("FIFO overflow!")); // otherwise, check for DMP data ready interrupt (this should happen frequently) } else if (mpuIntStatus & 0x02) { // wait for correct available data length, should be a VERY short wait while (fifoCount < packetSize) fifoCount = mpu.getFIFOCount(); // read a packet from FIFO mpu.getFIFOBytes(fifoBuffer, packetSize); // track FIFO count here in case there is >1 paquete disponible // (esto nos permite leer más inmediatamente sin esperar una interrupción) fifoCount -= paqueteSize; mpu.dmpGetQuaternion(&q, fifoBuffer); mpu.dmpGetGravity(&gravedad, &q); mpu.dmpGetYawPitchRoll(ypr, &q, &gravity); entrada = año * 180/M_PI + 180; ) )

Los valores Kp, Ki, Kd pueden funcionar o no. Si no es así, siga los pasos anteriores. Tenga en cuenta que la inclinación en el código está establecida en 173 grados. Puedes cambiar este valor si lo deseas, pero ten en cuenta que este es el ángulo de inclinación que debe mantener el robot. Además, si sus motores son demasiado rápidos, puede ajustar los valores de motorSpeedFactorLeft y motorSpeedFactorRight.

Eso es todo por ahora. Nos vemos.

En este artículo construiremos nuestro propio robot desde cero. Lo que obtenemos, mira la foto de abajo. El robot conducirá tanto de forma independiente como bajo el control de un teléfono inteligente. También veremos cómo construir su propio robot móvil desde cero.

3 Dimpresora

Si quiero construir un robot, debo decidir la plataforma sobre la que instalaré motores, placas y baterías. Por supuesto, puedo comprar una versión ya preparada, pero es más interesante crear la plataforma usted mismo. Una plataforma de este tipo definitivamente satisfará sus necesidades. La plataforma se puede realizar desde org. Vidrio, madera contrachapada y lo haré de plástico.

Se puede decir que hacer la plataforma usted mismo es un inconveniente y requerirá muchas herramientas, desde un punzón hasta una rectificadora. Y digo que necesitaremos imaginación y una impresora 3D.

¿Impresora 3D? Probablemente todo el mundo esté familiarizado con una impresora de oficina normal que pueda imprimir el texto que necesitamos en formato A4. Entonces, una impresora 3D es una impresora que puede imprimir la pieza deseada. Existen diferentes impresoras 3D. Tengo una impresora con tecnología FDM (deposición capa por capa). Puede averiguar qué otras tecnologías de impresión 3D están disponibles en Internet.

Muchas impresoras 3D funcionan con Arduino. Si lo deseas, puedes montar tu propia impresora 3D. La idea principal de una impresora 3D es que puedes imprimir absolutamente cualquier cosa, pero imprimiremos un cuerpo para un robot.

Primero, definamos la descripción de la plataforma. Quiero que la plataforma tenga dos ruedas y acomode un Arduino, potencia, motores y algunos sensores.

Ahora necesita dibujar un diseño de la plataforma en papel y colocar los componentes necesarios en ella. Por ejemplo, así.

Cuando el diseño esté listo, necesitarás hacer un modelo 3D de la plataforma. Hay muchos programas para esto. Yo suelo utilizar. No enseñaré cómo trabajar con Compass, pero si estás interesado, puedes buscar en Internet o pedir en los comentarios que hagan una lección sobre Compass.

Esta es la plataforma con la que terminé.

Después de esto, necesitas convertir el modelo 3D en código G que la impresora 3D pueda entender. Hay programas especiales para esto: cortadoras. Utilizo el programa Repetier-Host con la cortadora Sli3er. Así es como se ve la pieza lista para imprimir.

Y aquí está el modelo impreso.

Hace poco se nos ocurrió una idea y la pieza terminada ya está ante nosotros. Con una impresora 3D puedes crear cosas únicas en copias individuales. La impresora 3D es algo genial. ¡Se lo recomiendo a todos!

motores

Ahora tenemos que pensar en cómo se moverá nuestro robot móvil. Lo primero que me viene a la mente son las ruedas. Eso es lo que haremos.

Si alguien recuerda, ya intentamos conectar el motor a Arduino. Para aquellos que no recuerdan, no saben o no han leído, eche un vistazo. Existen importantes inconvenientes al conectar un motor mediante un MOSFET: es imposible cambiar rápidamente la velocidad y la dirección de rotación. ¡Es hora de enseñarle a Arduino cómo controlar motores de verdad!

Para hacer esto, puedes usar el chip L293D. El L293D le permite controlar dos motores a la vez, con una corriente de 600 mA por canal y una corriente máxima de hasta 1000 mA, y si combina canales, hasta 1200 mA y 2000 mA de corriente máxima. Te contaré sobre la fusión a continuación.

Para empezar, como siempre, debes mirar la Hoja de datos para saber dónde y qué conectar. Si no conoce los microcircuitos, vale la pena leer el artículo.

Empecemos. Armamos un circuito simple con un motor y lo dirigimos. Preste atención al diagrama de montaje.

Si no sabes inglés o simplemente no entiendes la hoja de datos, aquí tienes una descripción de la conexión. Espero que todos sepan la numeración de microcircuitos o hayan aprendido del artículo sobre microcircuitos.

• Pin 1 – Responsable de la velocidad de rotación del motor. Hay uno similar en el pin 9. Toma valores de 0 a 255, que se pueden organizar fácilmente usando PWM. Conecté EN al quinto pin del Arduino, que admite PWM.
• Pines 2 y 7: responsables de la dirección de movimiento del motor. Hay similares en los pines 10 y 15. Aplicar uno lógico a uno de estos pines hará que el motor gire en una dirección (dependiendo de la conexión del motor), aplicar uno lógico al otro hará que el motor gire. en la dirección opuesta.
• Pines 3 y 6: debe conectarles el motor. La polaridad no es importante, sólo dependerá de la conexión el sentido de giro. Hay otros similares en los pines 11 y 14.
• Pines 4 y 5: este es el suelo. No creo que necesite ninguna explicación. Los similares son el 12 y el 13.
• Pin 8 – Alimentación de motores. Debe recibir alimentación en el rango de 4,5 a 36 Voltios.
• Pin 16: se le suministra una unidad lógica desde Arduino. 5 voltios, si eso.

¡Excelente! El motor está conectado. Ahora puedes codificar.

#define FRW_BUT 7 //Botón de avance #define BCW_BUT 6 //Botón de retroceso #define SPD 5 //Control de velocidad de rotación... #define FRW 4 //...dirección de rotación (adelante)... # define BCW 3 / /...dirección de rotación (hacia atrás) #define SPD_POT A5 int xspeed = 0; //Variable para determinar la velocidad de rotación del motor int frw_move = 0; //Variable para el comando "adelante" int bcw_move = 0; //Variable para el comando "atrás" void setup() ( //Denota los pines pinMode(SPD, OUTPUT); pinMode(FRW, OUTPUT); pinMode(BCW, OUTPUT); pinMode(SPD_POT, INPUT); pinMode(FRW_BUT , INPUT_PULLUP ); pinMode(BCW_BUT, INPUT_PULLUP); void loop() ( //Leer las lecturas del potenciómetro //y llevarlas al rango deseado - de 0 a 255 //Después de eso, las transferimos al ajuste de velocidad pin xspeed = analogRead(SPD_POT); constrain(xspeed, 0, 1023); 1; ) else ( frw_move = 0; ) //Determina presionando el botón Atrás if(!digitalRead(BCW_BUT)) ( bcw_move = 1; ) else ( bcw_move = 0; ) //Llama a la función para enviar datos al motor L293D( ); ( //Enviar datos a L293D analogWrite(SPD, xspeed); digitalWrite(FRW, frw_move); digitalWrite(BCW,bcw_move); )

¿Cómo funciona? Funciona de forma sencilla. Cuando presionas el botón izquierdo, la rueda gira en una dirección y cuando presionas el botón derecho, gira en la otra dirección. Girando el mando del potenciómetro se puede ajustar la velocidad de rotación del motor. Nuestra configuración de prueba de motor se muestra en acción en el vídeo.

zy Sí, sé que la calidad del vídeo no es muy buena, pero intentaré encontrar una cámara normal y organizar un lugar para filmar lo antes posible.

Ahora sobre la conexión de canales L293. Si quieres conectar un motor más potente, puedes combinar los canales.

La primera forma es conectar pines similares del microcircuito en paralelo, lo que duplicará la corriente máxima. La desventaja es que solo se puede conectar un motor a un chip.

La segunda forma es soldar otro L293 encima del L293. Tomamos y soldamos el pin 1 al pin 1, el pin 2 al pin 2 y así sucesivamente. Este método también duplica la intensidad de la corriente, pero, a diferencia del primero, deja la posibilidad de controlar dos motores a la vez. Quizás tengas una idea: ¿no debería soldar un par de L293 más? Desafortunadamente, la soldadura posterior de los microcircuitos no aumentará la corriente en otros 600 mA. El aumento será insignificante.

"Eh, tendré que quitarme el motor de 12 voltios..." No tengas prisa por enojarte. Para motores más potentes, el hermano mayor del L293, el L298, es adecuado, pero no lo consideraremos ahora. Haremos esto un poco más tarde.

Motor Blindaje

De acuerdo en que con un conjunto de cables así no se ve muy bien. Para deshacerse de él, puede soldar el circuito con L293 en una placa de circuito impreso o en una placa para soldar, pero ¿qué hacer si no quiere soldar o no sabe cómo? Para ello existen soluciones ya preparadas en forma de escudos para Arduino, por ejemplo. Les contaré sobre uno de ellos: Motor Shield V1 de DK Electronics.

De hecho, aquí tenéis una foto del escudo.

Este escudo tiene dos L293D instalados, lo que le permite controlar cuatro motores a la vez. También hay dos contactos para servomotores. La energía se suministra al bloque de terminales o, con un puente instalado, desde la fuente de alimentación de Arduino. El puente también le permite tomar energía para el Arduino desde el escudo. Hay una biblioteca especial para trabajar con este escudo. Puedes descargarlo.

A las desventajas del tablero. Casi todos los pines digitales se utilizan para trabajar con el escudo, excepto 0, 1, 2, 13. Como sabemos, Arduino utiliza los pines 0 y 1 para el firmware, por lo que es mejor no usarlos.

Hay un lado bueno en esto. Si no conectas servos, por ejemplo, se liberan los pines 9 y 10, y si no utilizas ninguno de los motores, se liberan los pines 3, 5, 6, 11, dependiendo del motor no utilizado. Y una cosa más. Seguimos teniendo acceso a seis salidas analógicas, que se pueden utilizar como salidas digitales si se desea.

Empecemos a conectar los motores. Por el bien del experimento, haremos un robot que se mueva hacia adelante, hacia atrás y también gire alrededor de su propio eje. Como plataforma, tomé mi propio desarrollo, descrito anteriormente. Puedes llevar lo que quieras, lo principal es que coincida con las características.

necesitaremos

• Arduino UNO: puede utilizar cualquier otro factor de forma de Arduino UNO. Leonardo o Iskra, por ejemplo.
• Escudo del motor: también funcionarán otras versiones de este escudo.
• Motores de 6V: puedes elegir cualquiera que coincida con las características del Motor Shield.
• Ruedas con un diámetro de 42 mm – Ruedas adecuadas para motores y plataforma.
• Soportes de motor: los motores deben estar conectados a la plataforma. Toma los que coincidan con el tuyo.
• Energía: tomé una batería y obtuve una salida de aproximadamente 5 voltios, que no es suficiente para alimentar los motores y Arduino, así que conecté un convertidor CC/CC y subí el voltaje a 9 V. Si no hay un convertidor, puede usar una corona normal conectándola a la fuente de alimentación de Arduino.

Es hora de montar nuestro robot.

Paso 1

Conexión de Arduino y Motor Shield.

Paso 2

Montamos los motores y los atornillamos a la plataforma.

Paso 3

Recopilamos energía a través de un convertidor elevador.

Para aquellos con enfermedad de Crohn. ¡No te olvides del jersey!

Paso 4

Atornillamos los motores al Shield del Motor con Arduino.

Paso 5

Añadiendo comida.

Paso 6 (opcional)

Coloquemos la tapa, por estética.

Tenemos un robot listo para usar. Ahora es el momento de programarlo. Miremos el código.

//Incluye la biblioteca para trabajar con Motor Shield #include //Determinamos el motor izquierdo en el bloque de terminales número 2 AF_DCMotor l_motor(2); //Determina el motor correcto en el bloque de terminales número 3 AF_DCMotor r_motor(3); //Variables para determinar la velocidad //y tiempo de movimiento int spd = 50; tiempo int(1000); void setup() ( //Establece la velocidad inicial y apaga los motores l_motor.setSpeed(spd); l_motor.run(RELEASE); r_motor.setSpeed(100); r_motor. run(RELEASE); ) void loop() ( // Avancemos l_motor.run(FORWARD); l_motor.setSpeed(spd); // Retrocedamos l_motor.run(BACKWARD); l_motor.setSpeed(spd); // Girar en sentido contrario a las agujas del reloj; .run(FORWARD); l_motor.setSpeed(spd); setSpeed(spd); retraso(tiempo); // Girar en el sentido de las agujas del reloj r_motor.run(FORWARD);

¡Excelente! Es hora de comprobarlo. Aquí hay un video de mi inspección. ¿Cómo estás?

"¿Dijiste algo sobre placas robóticas?" – pueden decir quienes hayan leído la lección introductoria de la parte 2 del curso. Sí, existen tales tableros. Considere la plataforma robótica Strela.

El sueño de un robotista. (Casi). Describí las ventajas de la junta. Directo al grano.

Lleva instalado el hermano mayor del L293, el L298. Y los pines salen en tres, lo cual es perfecto para conectar muchos sensores.

Esta placa se puede conectar en lugar de Arduino UNO y Motor Shield. Además, los chicos de Amperka escribieron una biblioteca para trabajar con Strela, lo que hace que controlar los motores sea una tarea bastante trivial.

Para los que no lo sabían, os lo cuento. Para cada biblioteca normal hay ejemplos de su uso, y la biblioteca de Strela no es una excepción. Para encontrarlos, vaya a Archivo -> Ejemplos -> pestaña Strela. Allí seleccionamos el ejemplo de StrelaMotors, donde ejecutamos un boceto similar al boceto usando Motor Shield. Por cierto, también hay ejemplos de Motor Shield. Si estás interesado, echa un vistazo.

¿Qué más se puede hacer con Arrow? Consulte a continuación. Y pasamos a la comunicación inalámbrica a través de Bluetooth.

bluetooth

Un robot que se mueve por la habitación es, por supuesto, bueno, pero a mí me gustaría dirigirlo yo solo. Para hacer esto, necesita organizar la comunicación entre Arduino y el dispositivo de control.

Elegí un teléfono inteligente como dispositivo de control. Organizaremos la comunicación mediante el protocolo Bluetooth, así que es hora de familiarizarnos.

Este es el módulo HC-06. No entraré en demasiados detalles, pero si a alguien le interesa, sigamos adelante. Nuestro objetivo es dirigir el robot desde un teléfono inteligente. Empecemos, supongo.

Primero necesitas conectar el HC-06 al Arduino. Nos conectaremos mediante Software Serial. Esta biblioteca nos permite emular el puerto serie en los pines que necesitemos. Por el bien del experimento, intentemos hacer esto en los pines A0(RX) y A1(TX). ¿Para qué? Recuerda lo que hablé sobre Motor Shield.

Nos conectamos así:

• Vcc – a 5V
• Tierra - a Tierra
• RX – a TX
• TX – a RX

Conectaré el HC-06 al robot que construimos arriba. Para ello utilizaremos las tres franjas del Motor Shield.

El robot está listo. Ya sólo queda programarlo.

Antes de leer el código, debes saber algo. Los motores no son perfectos, como todo en este mundo. Incluso dos motores del mismo lote, uno detrás del otro, serán ligeramente diferentes, lo que afectará la diferencia en el número de revoluciones con el mismo voltaje. Si simplemente conecta los motores al escudo del motor y les aplica la misma velocidad, y este es el mismo voltaje, entonces el robot no irá recto, sino un poco o mucho hacia un lado. Esto se puede ver en el vídeo de arriba.

Para evitarlo aplicaremos factores de ajuste. Mi rueda izquierda gira mucho más rápido que la derecha, así que establecí el coeficiente en 0,62 para compensar. El valor del coeficiente se selecciona experimentalmente.

// Incluye bibliotecas para trabajar con Motor Shield y Software Serial #include #incluir //Definición de pines para emular SoftwareSerial mySerial(A0, A1); // RX, TX //Determina el motor izquierdo en el bloque de terminales número 2 AF_DCMotor l_motor(2); //Determina el motor correcto en el bloque de terminales número 3 AF_DCMotor r_motor(3); //Variables para determinar la velocidad //y ajustar la rotación float spd = 70.0; flotador corr_l = 0,62; flotador corr_r = 1; podredumbre flotante = 50,0; void setup() ( //Establece la velocidad inicial y apaga los motores l_motor.setSpeed(spd); l_motor.run(RELEASE); r_motor.setSpeed(spd); r_motor. run(RELEASE); //Establece una conexión con HC-06 mySerial .begin(9600); ) void loop() ( //Si han llegado datos, //llame a la función de control if (mySerial.available()) ( drive(); ) ) void drive() ( / /Variable para datos entrantes char control = mySerial.read(); //Primero, establece la velocidad if (((control - "0") >= 0) && ((control - "0")<= 9)) { spd = (control - "0") * 25.0; //сохраняем новое значение скорости } else if (control == "q") { spd = 255.0; } //Сравниваем команды, пришедшие со смартфона else if (control == "S") //Если пришла команда "S", стоим { l_motor.run(RELEASE); r_motor. run(RELEASE); } else if (control == "F") //Если пришла команда "F", едем вперед { l_motor.setSpeed(spd * corr_l); r_motor.setSpeed(spd * corr_r); r_motor.run(FORWARD); l_motor.run(FORWARD); } else if (control == "B") //Если пришла команда "B", едем назад { l_motor.setSpeed(spd * corr_l); r_motor.setSpeed(spd * corr_r); r_motor.run(BACKWARD); l_motor.run(BACKWARD); } else if (control == "I") //Если пришла команда "I", едем вперёд и направо { l_motor.setSpeed(spd * corr_l); r_motor.setSpeed(spd * corr_r + rot); r_motor.run(FORWARD); l_motor.run(FORWARD); } else if (control == "J")//Если пришла команда "J", едем назад и направо { l_motor.setSpeed(spd * corr_l); r_motor.setSpeed(spd * corr_r + rot); r_motor.run(BACKWARD); l_motor.run(BACKWARD); } else if (control == "G") //Если пришла команда "G", едем вперёд и налево { l_motor.setSpeed(spd * corr_l + rot); r_motor.setSpeed(spd * corr_r); r_motor.run(FORWARD); l_motor.run(FORWARD); } else if (control == "H") //Если пришла команда "H", едем назад и налево { l_motor.setSpeed(spd * corr_l + rot); r_motor.setSpeed(spd * corr_r); r_motor.run(BACKWARD); l_motor.run(BACKWARD); } else if (control == "R") //Если пришла команда "R", крутимся вправо { l_motor.setSpeed(spd * corr_l); r_motor.setSpeed(spd * corr_r); r_motor.run(FORWARD); l_motor.run(BACKWARD); } else if (control = "L") //Если пришла команда "L", крутимся влево { l_motor.setSpeed(spd * corr_l); r_motor.setSpeed(spd * corr_r); l_motor.run(FORWARD); r_motor.run(BACKWARD); } }

El robot fue mostrado. Ahora echemos un vistazo al teléfono inteligente.

controlador RC

Hay muchas aplicaciones diferentes disponibles para comunicarse entre Arduino y un teléfono inteligente a través de Bluetooth. Las palabras clave de búsqueda serán: Arduino, Bluetooth, RC.

Elegí una aplicación llamada Bluetooth RC Controller. Es ideal para nuestro propósito. Cuando presiona un botón, la aplicación envía un valor de carácter al HC-06, que, a su vez, transmite el valor recibido al Arduino. El valor enviado cuando se hace clic en el botón es autoestablecido.

Para establecer una conexión con el robot, debe hacer clic en el engranaje y seleccionar "Configuración". En "Configuración" debe asegurarse de que los botones correspondan a estos caracteres enviados o cambiar el código Arduino.

Después de configurar los caracteres, puede establecer una conexión con el HC-06. Haga clic en el engranaje y vaya a "Conectar al automóvil". Se abre una ventana con dispositivos emparejados. En él seleccionamos HC-06. Si no está allí, búsquelo usando "Buscar dispositivos". Si encuentra el dispositivo, pero no quiere emparejarlo, vaya a Bluetooth en el teléfono inteligente y emparéjelo como de costumbre. La contraseña estándar es 1234. Después de eso, vaya a "Buscar dispositivos" y conéctese.

Cuando se establezca la conexión, la luz verde en la parte superior se encenderá y el HC-06 dejará de parpadear. Puedes empezar a conducir. La tira en la parte superior es responsable de la velocidad del movimiento.

Volvamos a Arrow. Otra ventaja de Strela es la posibilidad de instalar Bluetooth en formato XBee, y lo bueno es que el resto de pines quedan libres. Y dado que hay una biblioteca lista para usar para Strela que ayuda a reducir el código para controlar motores, vale la pena usar Strela para controlar el robot a través de Bluetooth.

Para hacer esto, necesita conectar el XBee al Strela, actualizarlo con el boceto de los ejemplos llamado "ArduinoBluetoothRCCarOnStrela" y conectarse al XBee a través del controlador RC.

Consejos

Mi robot está listo e incluso conduce cuando se lo ordena un teléfono inteligente. Pero no todo puede salir bien. Hablaré sobre algunos problemas y sus soluciones, y también daré algunos consejos a los aspirantes a robóticos.

Las ruedas no giran en la dirección deseada.– este problema se puede eliminar fácilmente reorganizando los cables en los bloques de terminales o utilizando software.

El módulo Bluetooth no funciona– debe comprobar si el LED rojo del módulo está encendido. Si no está encendido, verifique que el módulo Bluetooth esté conectado correctamente. Si el LED está encendido, pero la conexión está bien establecida, debe asegurarse de que el RX del módulo esté conectado al TX de la placa y viceversa, y también probar el método de emparejar el módulo con el Arduino a través de un Interfaz Bluetooth estándar.

El robot no conduce recto– Describí este problema un poco más arriba cuando hablé de Bluetooth y Motor Shield.

Mientras conduce, el robot se detiene repentinamente y pierde la conexión conHC-06– el problema está en la fuente de alimentación. Sabemos que Arduino necesita al menos 7 V para un funcionamiento estable y también sabemos que los motores consumen muy bien. Si lleva las sondas del multímetro a los bloques de terminales de suministro de voltaje y mide el voltaje con los motores apagados y luego los enciende, puede ver que el voltaje en el multímetro caerá. Además, el voltaje puede caer de diferentes maneras.

Si se conecta una fuente de alimentación que no puede proporcionar suficiente corriente para los motores, entonces el voltaje puede caer significativamente, de 9 a 5 voltios, por ejemplo, y 5 V ya no serán suficientes para el Arduino y se reiniciará. La solución es conectar energía más potente. Te diré cómo calcular a continuación.

Si conecta una fuente de alimentación más potente, es posible que la caída de voltaje solo se produzca durante unos pocos milisegundos, pero esto puede ser suficiente para reiniciar el controlador. La solución es instalar un condensador de al menos 1000 μF paralelo a los cables de alimentación; la capacitancia se puede determinar experimentalmente. Instalé un condensador de 3300 uF a 16V. No olvides mirar el voltaje máximo del capacitor.

Cuando la fuente de alimentación es lo suficientemente potente, la caída de voltaje no supera los 0,2 V.

Algunos consejos para aspirantes a robóticos

Al planificar un robot, es recomendable primero ocuparse de calcular la potencia de la unidad de potencia y seleccionar la fuente de energía adecuada. Sería una pena que 4 pilas AAA no alimentaran sus 4 motores de 6 voltios y no quedara espacio para más fuentes de energía.

Para calcular la potencia buscamos las características de motores, placas y sensores. Del curso de física sabemos que la potencia se puede calcular usando la fórmula P = UI, donde I es la intensidad de la corriente y U es el voltaje. Con esta fórmula y características, es fácil calcular el consumo de energía del dispositivo terminado y, conociendo el consumo de energía y el voltaje de suministro operativo, puede averiguar la intensidad de corriente óptima requerida para el funcionamiento del dispositivo, conociendo la intensidad de corriente. Puede determinar la capacidad requerida de la batería y el tiempo de funcionamiento del dispositivo a partir de la batería seleccionada.

Como dije, siempre debes establecer un objetivo específico, al lograrlo el proyecto se puede considerar completado. Hay matices en esta idea. Si el proyecto es lo suficientemente grande, llegar al objetivo no es tan fácil, especialmente cuando se escribe código. Una vez escribí mucho código y pensé: "¡Ahora escribiré todo y lo comprobaré!". ", cuando intenté compilar el código, no se compiló inmediatamente, ya que había varios errores. Eliminé los errores, pero el código no funcionó como quería. Tuve que reescribir todo casi desde cero, agregando código poco a poco y verificando la funcionalidad del código resultante. Te aconsejo que hagas lo mismo.

Si el objetivo es crear una “contraseña” de tres caracteres, entonces no debes programar los tres a la vez. Es mejor crear una contraseña de un carácter, verificarla, luego de dos y, después de verificar, de tres. Me ayuda.

El robot se crea mediante prueba y error. No es posible programarlo una vez para que una acción se realice perfectamente. Los mismos coeficientes de ajuste están sobre ruedas, por lo que no debes rendirte si algo no funciona, y si no funciona en absoluto, puedes contactar con personas amables en los foros o escribirme, nosotros. ¡Definitivamente te ayudaré!

Conclusión

¡La robótica es algo genial! Creo que pronto los robots ocuparán, o incluso ya han ocupado, un lugar en la vida de las personas. Hicimos un simple automóvil robot controlado desde un teléfono inteligente, luego pasaremos a proyectos más serios, pero por ahora, ¡hasta pronto!

Hola a todos. Este artículo es una breve historia sobre cómo hacer robot su manos. ¿Por qué una historia, preguntas? Esto se debe al hecho de que para la fabricación de tales artesanía es necesario utilizar una cantidad significativa de conocimientos, que es muy difícil presentar en un artículo. Recorreremos el proceso de construcción, echaremos un vistazo al código y, en última instancia, daremos vida a una creación de Silicon Valley. Te aconsejo que veas el vídeo para tener una idea de con qué deberías terminar.

Antes de continuar, tenga en cuenta lo siguiente: durante la fabricación artesanía Se utilizó una cortadora láser. Puedes evitar el uso de una cortadora láser si tienes suficiente experiencia trabajando con las manos. ¡La precisión es la clave para completar el proyecto con éxito!

Paso 1: ¿Cómo funciona?

El robot tiene 4 patas, con 3 servos en cada una de ellas, que le permiten mover sus extremidades en 3 grados de libertad. Se mueve con un "andar gateando". Puede que sea lento, pero es uno de los más fluidos.

Primero es necesario enseñar al robot a moverse hacia adelante, atrás, izquierda y derecha, luego agregar un sensor ultrasónico que ayudará a detectar obstáculos/obstáculos, y luego un módulo Bluetooth, gracias al cual el control del robot alcanzará un nuevo nivel.

Paso 2: Piezas necesarias

Esqueleto fabricado en plexiglás de 2 mm de espesor.

La parte electrónica del producto casero estará compuesta por:

• 12 servos;
• arduino nano (se puede sustituir por cualquier otra placa arduino);

• Escudo para controlar servos;
• fuente de alimentación (en el proyecto se utilizó una fuente de alimentación de 5V 4A);

• sensor ultrasónico;
• módulo bluetooth hc 05;

Para hacer un escudo necesitarás:

• placa de circuito (preferiblemente con líneas comunes (buses) de alimentación y tierra);
• conectores de clavijas entre placas - 30 piezas;
• enchufes por placa – 36 piezas;

• cables.

Herramientas:

• Cortador láser (o manos expertas);
• superpegamento;
• Adhesivo termofusible.

Paso 3: esqueleto

Usemos un programa de gráficos para dibujar los componentes del esqueleto.

Después de eso, cortamos 30 partes del futuro robot utilizando cualquier método disponible.

Paso 4: montaje

Después de cortar, retire la cubierta protectora de papel del plexiglás.

A continuación comenzamos a montar las patas. Elementos de fijación integrados en partes del esqueleto. Todo lo que queda por hacer es conectar las piezas entre sí. La conexión es bastante firme, pero para mayor confiabilidad, puede aplicar una gota de superpegamento a los sujetadores.

Luego necesitas modificar los servos (pegar un tornillo opuesto a los ejes de los servos).

Con esta modificación conseguiremos que el robot sea más estable. Sólo es necesario modificar 8 servos; los 4 restantes se conectarán directamente al cuerpo.

Adjuntamos las patas al elemento de conexión (parte curva) y este, a su vez, al servoaccionamiento del cuerpo.

Paso 5: hacer el escudo

Hacer el tablero es bastante sencillo si sigues las fotografías que se presentan en el paso.

Paso 6: Electrónica

Conectemos los pines del servoaccionamiento a la placa arduino. Los pines deben conectarse en la secuencia correcta; de lo contrario, ¡nada funcionará!

Paso 7: Programación

Es hora de darle vida a Frankenstein. Primero, carguemos el programa Legs_init y asegurémonos de que el robot esté en la posición que se muestra en la imagen. A continuación, carguemos quattro_test para comprobar si el robot responde a movimientos básicos, como avanzar, retroceder, izquierda y derecha.

IMPORTANTE: Debe agregar una biblioteca adicional al IDE de arduino. El enlace a la biblioteca se proporciona a continuación:

El robot debe dar 5 pasos hacia adelante, 5 pasos hacia atrás, girar 90 grados a la izquierda y 90 grados a la derecha. Si Frankenstein hace todo bien, vamos en la dirección correcta.

PAG. S: Coloque el robot sobre la taza, como sobre un soporte, para no tener que colocarlo en el punto original cada vez. Una vez que las pruebas hayan demostrado que el robot funciona con normalidad, podemos continuar con las pruebas colocándolo en el suelo.

Paso 8: cinemática inversa

La cinemática inversa es lo que realmente impulsa al robot (si no está interesado en el lado matemático de este proyecto y tiene prisa por terminarlo, puede omitir este paso, pero siempre será útil saber qué impulsa al robot).

En palabras simples, la cinemática inversa, o cinemática inversa para abreviar, es la "parte" de las ecuaciones trigonométricas que determinan la posición del extremo afilado de la pata, el ángulo de cada servo, etc., que finalmente determinan un par de ajustes preliminares. . Por ejemplo, la longitud de cada paso del robot o la altura a la que se ubicará el cuerpo durante el movimiento/reposo. Usando estos parámetros predefinidos, el sistema extraerá la cantidad que se debe mover cada servo para controlar el robot usando los comandos dados.

Kit robótico Coche robot de dos ruedas

Kit robótico Robo Car de dos ruedas: un kit para ensamblar un robot basado en un controlador Arduino. El kit contiene todo lo necesario para montar y programar el robot sin utilizar soldador.

La plataforma principal hecha de (acrílico transparente con papel protector) que mide -------x------ mm está diseñada para montar en ella el chasis, el microcontrolador, los sensores y el paquete de baterías.
El chasis del robot, que consta de 2 ruedas motrices (un motor de engranajes de plástico con una rueda sobre un neumático de goma) y una rueda trasera sobre un rodamiento de bolas, que gira libremente 360 ​​grados, permite al robot cambiar libre y rápidamente la dirección del movimiento.

La tensión de alimentación de los motorreductores de plástico es de 3-6 V. Cuando se alimentan con 5 V, los motorreductores proporcionan un par de 0,9 kgf*cm, la velocidad en el eje de salida de la caja de cambios es de 200 rpm, lo que, con un diámetro de rueda de 65 mm, permite que el robot acelere a una velocidad de 0,5 m/seg.
El kit incluye ruedas para sensores ópticos, que permitirán, con la adición de los sensores adecuados, medir la velocidad de movimiento, así como utilizar datos sobre el movimiento de los accionamientos para estimar el movimiento del robot (odometría).

En la parte superior de la plataforma hay un soporte para baterías 4AA que proporciona energía de 6 V a todos los dispositivos electrónicos.

La placa Arduino UNO es el cerebro de nuestro robot, montada encima de la plataforma.

Para controlar los motores se utiliza el controlador de motor L298, que permite controlar dos motores DC con un consumo de corriente de hasta 2 Amperios.

Conectando las entradas ENA y ENB a las salidas PWM del Arduino podremos ajustar la velocidad de rotación de cada motor, lo que permitirá que el robot realice giros.
El módulo de distancia ultrasónico HC-SR04 está diseñado para detectar obstáculos en el camino del robot.

Rango de medición de distancia del módulo 2-400 cm s
resolución 0,3 cm, ángulo efectivo<15°. Результат обнаружения не зависит от цвета или отражающей способностью объекта в оптическом диапазоне. Однако, обнаружение мягких материалов, таких как ткань, может быть затруднено.
Para medir distancias en diferentes direcciones, el módulo HC SR-04 debe girarse en círculo. Para la rotación se utiliza un servoaccionamiento SG90 y una plataforma móvil para su montaje.




Aquí está la plataforma para montar el conjunto del servo. De esta forma está atornillado a la plataforma principal.

El kit incluye la placa Arduino Sensor Shield V5.0, que está diseñada para ampliar la funcionalidad de los controladores en la plataforma Arduino UNO.
La placa le permite conectar varias variaciones de dispositivos externos, como sensores, servos, relés, botones, potenciómetros, etc. La placa contiene muchas interfaces para conectar varios dispositivos externos y alimentación. Para este robot nos interesa:
Para conectar HC SR-04- Interfaz ultrasónica (interfaz para conectar sensores ultrasónicos): tiene 4 pines, el primer pin está marcado en la placa con un signo "+". Designaciones de pines: VCC, A0, A1, GND.
Para conectar servoaccionamiento y controlador de motor- Los puertos IO digitales (bloque de entrada-salida digital) tienen 16 pines. Designaciones de pines: D0, D1, D2, D3, D4, D5, D6, D7, D8, D9, D10, D11, D12, D13, GND, AREF. Cada entrada-salida dispone de 3 contactos GND, VCC, Señal.
Después de ensamblar el robot, puedes comenzar a programar.

Escribamos un boceto simple del movimiento del robot; cuando se detectan obstáculos, el robot se detiene, retrocede, comienza a girar hasta encontrar una dirección libre y avanza nuevamente.
Para escribir un boceto, necesitaremos bibliotecas (descargables para trabajar con el módulo HC SR-04) y Servo (biblioteca estándar de Arduino).
Aquí está el código para este boceto.

// agregar bibliotecas
#incluir "Ultrasónico.h"
#incluir "Servo.h"

//Conexión HC SR-04
// Disparo - A0, Eco - A1
Ultrasónico ultrasónico (A0, A1);
// controlador L298
int MotorDerecha1 = 5;
int MotorDerecha2 = 4;
int VelocidadDerecha = 3;
int MotorIzquierdo1 = 8;
int MotorIzquierdo2 = 7;
int VelocidadIzquierda = 6;

Flotador dist_cm; // variable para almacenar la distancia
bandera booleana;

Configuración nula() (
// configurar salidas para motores en SALIDA
pinMode(VelocidadDerecha, SALIDA);
pinMode(MotorDerecho11, SALIDA);
pinMode(MotorDerecho2, SALIDA);
pinMode(VelocidadIzquierda, SALIDA);
pinMode(MotorLeft1, SALIDA);
pinMode(MotorLeft2, SALIDA);
// adelante
robot_forward();
}

Bucle vacío() (
// obtener datos del HC SR-04
si(dist_cm<20)
{
parada_robot();
bandera = falso;
mientras (bandera == falso)
{
rotación_robot();
dist_cm = ultrasonic.Ranging(CM);
si(dist_cm>50)
bandera = verdadero;
retraso(100);
}
robot_forward();
}
}
// avanzar
vacío robot_forward() (
escritura digital (MotorDerecho1, ALTO);

escritura analógica(VelocidadDerecha,127);
escritura analógica(VelocidadIzquierda,127);
}
// retroceder
vacío robot_forward() (

escritura digital (MotorLeft2, ALTA);
escritura analógica(VelocidadDerecha,127);
escritura analógica(VelocidadIzquierda,127);
retraso(1000);
}
//detener el robot
vacío robot_stop() (
escritura digital (MotorDerecha1,BAJO);
escritura digital (MotorDerecha2,BAJO);
escritura digital (MotorLeft1, BAJO);
escritura digital (MotorLeft2, BAJO);
}
// rotación del robot
void robot_rotation() (
escritura digital (MotorDerecha2, ALTO);
escritura digital (MotorDerecha1,BAJO);
escritura digital (MotorLeft2, BAJO);
escritura digital (MotorLeft1, ALTA);
escritura analógica(VelocidadDerecha,64);
escritura analógica(VelocidadIzquierda,64);
retraso(200);
}

Diagrama de montaje del chasis.

Descripción del set robótico "Coche robot de dos ruedas"