Introducción

Proyecto tortuga robot es un sistema de desarrollo de aplicaciones de aprendizaje de microcontroladores. Está basado en la serie de microcontroladores ARDUINO atmega-328. Tiene funciones como seguimiento de línea, prevención de obstáculos, control remoto por infrarrojos y control remoto inalámbrico Bluetooth. Este kit contiene muchos programas interesantes. También se puede ampliar para que el módulo de circuito externo tenga otras funciones. Este kit está diseñado para ayudarlo a aprender Arduino de forma interesante y entretenida.

Parámetros

1. Parámetros del motor: rango de tensión: 1.5-12V; longitud del eje del motor: 10 mm; velocidad de rotación: 6.0 V 100 RPM / min.
2. Utilice el módulo de controlador L298N para el control del motor, verdadera separación del microcontrolador.
3. Tres módulos de seguimiento de línea, la detección de línea en blanco y negro, alta precisión, también se puede utilizar en la prevención de caídas.
4. El módulo de comunicación remota por infrarrojos constituye el sistema de control remoto.
5. El módulo ultrasónico constituye el sistema de prevención de obstáculos.
6. Con el módulo inalámbrico bluetooth, controle remotamente el robot después del emparejamiento bluetooth con el teléfono móvil.
7. Puede ser utilizado bajo voltaje externo de 7 ~ 12V, también con varios módulos de sensor para realizar diversas funciones.

Lista de componentes

No.	nombre del producto	Cantidad	Imagen
1	keyestudio UNO R3	1
2	Keyestudio BEE Shield V5	1
3	Keyestudio L298N Motor Shield	1
4	Keyestudio Bluetooh XBee HC-06	1
5	Sensor de seguimiento de línea keyestudio	1
6	Sensor ultrasónico HC-SR04	1
7	Módulo de receptor de IR digital keyestudio	1
8	PCB superior	1
9	PCB inferior	1
10	Servo motor	1
11	Plataforma servoplástica	1
12	Rueda omnidireccional	2
13	Metal Gear Motor + Wire	2
14	Soporte del motor de engranajes	2
15	Conmutador + cable	1
16	Rueda de 43 * 19MM	2
17	Caja de la batería	1
18	Separadores M3 * 12 + 6	4
19	Separadores M3 * 10MM	8
20	Separadores M3 * 45MM	4
21	Tornillo M2 * 12MM	4
22	Perno M3 * 6MM	2
23	Tuerca M3	10
24	Tuerca M2	4
25	Tornillo M3 * 6MM	32
26	Cable de 3 pines Dupont	3
27	Cable Dupont	14
28	Tubo sinuoso	1
29	Amarras plásticas	6

Lista de proyectos

1. Aplicación de la placa de controlador de motor L298N
2. Seguimiento de coche inteligente
3. Coche inteligente de evitación de obstáculo ultrasónico
4. Coche inteligente de control remoto infrarrojo
5. Coche inteligente programable de control remoto Bluetooth de
6. 4 en 1 (seguimiento de línea; evitación de obstáculos; Control remoto de infrarrojos control, control remoto por bluetooth) programa multifuncional

Aplicación de Arduino

Introducción

¿Qué es Arduino?
Arduino es una plataforma de proyecto de hardware de código abierto. Esta plataforma incluye una placa de circuito con una función de E / S simple y un software de entorno de desarrollo de programa. Se puede usar para desarrollar productos interactivos. Por ejemplo, puede leer señales de múltiples interruptores y sensores, y controlar la luz, el servomotor y otros diversos dispositivos físicos. Se aplica ampliamente en el campo de los robots.

Instalación de Arduino y carga del programa:
Primero, descargue el software de desarrollo Arduino, haga clic debajo del hipervínculo:
https://www.arduino.cc/en/Main/OldSoftwareReleases#1.5.x

El archivo descargado es un arduino-1.5.6-r2-windows .zip comprimido carpeta, descomprimirlo en su disco duro.
Haga doble clic en Arduino-1.5.6 .exe. Haga clic en «I Agree»;

Haga clic en «Next»;

Y luego «Install»;

Espere a que se complete la instalación, haga clic en «Close».

A continuación se muestra cómo se ve Arduino 1.5.6.

Luego, instalemos el controlador Arduino. 
Para diferentes sistemas operativos, puede haber una ligera diferencia en el método de instalación. A continuación se muestra un ejemplo en WIN 7.
Cuando conectas Arduino Uno a tu computadora la primera vez, haz clic derecho en «Equipo» -> «Propiedades» -> «Administrador de dispositivos», puedes ver «Dispositivos desconocidos».

Haga clic en «Dispositivos desconocidos», seleccione «Actualizar software del controlador».

En esta página, haga clic en «Buscar en mi computadora el software del controlador».

Encuentra el archivo «drivers».

Haga clic en Siguiente»; seleccione «Instalar este software de controlador de todos modos» para comenzar la instalación.

Instalación completa; haga clic en «Cerrar».

Después de instalar el controlador, vuelva a «Administrador de dispositivos». Haga clic derecho en «Equipo» -> «Propiedades» -> «Administrador de dispositivos», puede ver el dispositivo UNO como muestra la figura a continuación, también la información del puerto Com.

A continuación se muestra un ejemplo de carga del sketch llamado «¡Hola mundo!».
Primero, abra Arduino IDE. En este bosquejo de ejemplo, programamos Arduino para mostrar «Hello World!» En el monitor serie cuando recibe una cadena de caracteres específica «R»; también el LED D13 incorporado parpadeará una vez cada vez que reciba «R».
Primero, configure el tablero; En «Herramientas», selecciona «Arduino Uno».

A continuación, configure el puerto COM; En «Herramientas», selecciona «COM3».

Después de la selección, puede ver que el área indicada es la misma con la configuración en «Administrador de dispositivos».

Copie el sketch de ejemplo y péguelo en el IDE; haga clic en «Verificar » para verificar los errores de compilación; haga clic en «Cargar » para subir el programa a la pizarra.

Después de finalizar la carga, abra el «monitor serie «; ingrese «R»; haga clic en «Enviar», el monitor de serie mostrará «¡Hola mundo!» y el LED D13 parpadeará una vez.

¡Felicitaciones! ¡Su primer sketch de carga es un éxito!

Detalles del proyecto

1) Aplicación de la tarjeta driver L298 para los motores 

Para obtener instrucciones sobre la placa de accionamiento L298N, consulte (manual de la placa de accionamiento del motor de CC del puente dual-L L298N).

Para la parte del controlador VMS, la fuente de alimentación puede ser una fuente de alimentación externa, generalmente de alrededor de 9V. Para la parte lógica, la fuente de alimentación puede ser desde la placa internamente; con terminales en estado de suspensión, también se pueden conectar a una potencia de + 5V a + 7V. Los tres pines entre cada terminal se utilizan para controlar el motor dual de CC. EA y EB están conectados a la interfaz Arduino PWM para la regulación de la velocidad del motor. Las interfaces I1, I2, I3, I2, conectadas a las interfaces digitales Arduino, se utilizan para controlar el motor en avance, retroceso, dirección y frenado. Hasta ahora, el trabajo preparatorio está completo. Puedes comenzar a escribir el programa ahora. Aquí, el programa para su referencia incluye un automóvil que va recto, hacia atrás, girando a la izquierda, girando a la derecha y frenando.

Programa:

int pinI1 = 5; // definir pin I1
int pinI2 = 6; // definir pin I2
int speedpin = 3; // definir pin EA (regulación de velocidad PWM)
int pinI3 = 10; // definir pin I3
int pinI4 = 11; // definir pin I4
int speedpin1 = 9; // definir pin EB (regulación de velocidad PWM)
Configuración de vacío ()
{
pinMode (pinI1, SALIDA);
pinMode (pinI2, SALIDA); 
pinMode (speedpin, OUTPUT);
pinMode (pinI3, SALIDA);
pinMode (pinI4, SALIDA); 
pinMode (speedpin1, OUTPUT);
}
void loop ()
{
// ir derecho 
analogWrite (speedpin, 100); // valor analógico de entrada para establecer la velocidad
analogWrite (speedpin1,100);
digitalWrite (pinI4, LOW); // hace que el motor de CC gire (hacia la derecha) en sentido antihorario
digitalWrite (pinI3, ALTO);
digitalWrite (pinI1, LOW); // hacer girar el motor de CC (izquierda) en el sentido de las agujas del reloj
digitalWrite (pinI2, ALTO);
retraso (2000);
// yendo hacia atrás
analogWrite (speedpin, 100); // valor analógico de entrada para establecer la velocidad 
analogWrite (speedpin1,100);
digitalWrite (pinI4, HIGH); // hace que el motor de CC gire (hacia la derecha) en el sentido de las agujas del reloj
digitalWrite (pinI3, BAJO); 
digitalWrite (pinI1, HIGH); // hace que el motor de CC gire (izquierda) en sentido contrario a las agujas del reloj
digitalWrite (pinI2, BAJO);
retraso (2000);
// girando a la izquierda
analogWrite (speedpin, 60); // valor analógico de entrada para establecer la velocidad 
analogWrite (speedpin1,60);
digitalWrite (pinI4, LOW); // hace que el motor de CC gire (hacia la derecha) en sentido antihorario
digitalWrite (pinI3, ALTO);
digitalWrite (pinI1, HIGH); // hace que el motor de CC gire (izquierda) en sentido contrario a las agujas del reloj
digitalWrite (pinI2, BAJO);
retraso (2000);
// girando a la derecha 
analogWrite (speedpin, 60); // valor analógico de entrada para establecer la velocidad 
analogWrite (speedpin1,60);
digitalWrite (pinI4, HIGH); // hace que el motor de CC gire (hacia la derecha) en el sentido de las agujas del reloj
digitalWrite (pinI3, BAJO);
digitalWrite (pinI1, LOW); // hacer girar el motor de CC (izquierda) en el sentido de las agujas del reloj
digitalWrite (pinI2, ALTO);
retraso (2000);
// frenando
digitalWrite (pinI4, HIGH); // hacer que el freno de motor de CC (derecha) 
digitalWrite (pinI3, ALTO); 
digitalWrite (pinI1, HIGH); // hace que el freno de motor de CC (izquierda) 
digitalWrite (pinI2, ALTO);
retraso (2000);
}

Nota: en el programa, puede haber otras formas de hacer que el motor gire a la izquierda o a la derecha. Puedes probarlo tú mismo.

2) Línea de seguimiento de coche inteligente

Principio de seguimiento de línea: el principio de funcionamiento del doble tubo infrarrojo TCRT5000 es utilizar la reflectividad diferente del infrarrojo de diferente color y convertir la intensidad de la señal reflejada en señal actual. Para el módulo de seguimiento de línea en blanco y negro, es señal de alto nivel cuando se detecta la línea negra, bajo nivel cuando se detecta la línea blanca. La altura de detección es de 0-3 cm.

Nota: puede usar un potenciómetro de perilla en el circuito para ajustar la sensibilidad de este módulo de seguimiento. El doble tubo infrarrojo TCRT5000 se aplica ampliamente en el diseño de robots y la fabricación industrial. Se puede utilizar para robots de seguimiento de líneas en blanco y negro y sensores de recuento industriales.

Uso:

1. Para el sensor, hay 3 pines, a saber, GND, VCC, OUT. VCC y GND son para suministro de energía. OUT es para salida de señal.
2. Cuando detecta un objeto, el extremo de la señal produce un nivel bajo; cuando no se detecta ningún objeto, el extremo de la señal produce un alto nivel.
3. Al juzgar si la salida de señal es 0 o 1, puede saber si el objeto existe.

Parámetro de rendimiento:

1. Distancia de detección: aproximadamente 2 cm para el piso de papel blanco. La distancia diferente depende de la diferencia de color, más lejana para el color blanco.
2. Voltaje de suministro de energía: 2.5V a 12V, no más de 12V. (nota: es mejor utilizar fuente de alimentación de baja tensión, el alto voltaje de alimentación dará como resultado una menor vida útil del sensor. Se prefiere
la fuente de alimentación de 5 V. ) 2. Corriente de trabajo: 18 ~ 20ma cuando el voltaje de alimentación es de 5V. Después de muchas pruebas, cuando la corriente de trabajo es de 18 ~ 20ma, el sensor está en su mejor rendimiento en capacidad anti-jamming.
3. Cuando detecta un objeto, el extremo de la señal produce un nivel bajo; cuando no se detecta ningún objeto, el extremo de la señal produce un alto nivel.
5. El sensor emite el nivel de TTL; se puede conectar directamente al puerto IO de 3.3V o 5V MCU.

Principio de detección de línea negra o blanca:

1. Para el color negro, tiene una característica de baja reflectividad a la luz. Cuando el color de la superficie no es negro, se reflejará la mayor parte de la luz roja que envía el sensor. El sensor emite un nivel bajo 0.
2. Si hay una línea negra en una superficie, cuando el sensor está encendido, el color negro tiene baja reflectividad; La luz infrarroja reflejada no es suficiente para alcanzar el nivel de acción del sensor, por lo que la salida del sensor sigue siendo l.
3.Para detectar la línea negra, solo necesitamos una MCU para determinar si la salida del sensor es 0 o 1.
4. El principio de detección de la línea blanca es el mismo con la línea negra. Cuando se detecta una línea blanca, el color que rodea a la línea blanca está cerca del negro. Luego ajustamos la resistencia ajustable del sensor infrarrojo; disminuya la sensibilidad hasta que no se pueda detectar el color circundante. El sensor puede detectar la línea blanca.

Programa de prueba:

int inputpin = 7; // definedigital pin 7 como puerto de detección
int val; // definir variable
Configuración de vacío ()
{
pinMode (inputpin, INPUT); // establece el pin digital 7 como salida
Serial.begin (9600); // establece la velocidad en baudios en 9600 para el puerto serie
}
void loop ()
{
val = digitalRead (inputpin); // lee el valor del puerto digital
Serial.println (val); // muestra el valor del puerto digital}

Línea de seguimiento de coche inteligente

After some basic knowledge of line tracking module, let’s make our own line tracking smart car. This design of line tracking car system is base on Arduino . It includes software and hardware design. The controller unit of the car is Arduino UNO, using infrared photoelectric sensor to detect the black track and feedback the information to the Arduino board. Arduino board will have analysis of the acquired information, timely control the driver motor to adjust the moving direction of the car. So the car can drive automatically along the black track, realizing the line tracking function. the system design is as below figure 1-1.

Car tracking principle:here, tracking means the car will move along the black line on the white floor. Because the black line and the white floor has different reflection coefficient, the track can be determine by the strength of the reflected light. Usually, it adopts the method of infrared detection. That is to use infrared ray’s feature of reflection over different color. When the car is driving, it will continually emit infrared ray to the ground. When the infrared ray encounters the floor made of white paper. It will be reflected. The reflected ray will be received by the receiver of the car. If it encounters the black track, infrared ray will be absorbed so the receiver won’t receive infrared ray. The microcontroller will determine the location of the black line and the moving direction of the car. Note that the detection rage of the infrared detector is limited.

El sistema de control del vehículo de seguimiento de línea consta de un módulo de circuito de control principal, un módulo de fuente de alimentación, un módulo de detección de infrarrojos, un motor y un módulo de controlador. El diseño del sistema de control es como se ve a continuación figura 2-1.

Diagrama de flujo del coche de seguimiento de línea:

Cuando el automóvil ingresa al modo de rastreo, comienza a escanear constantemente el puerto de E / S de la MCU. Cuando el puerto de E / S capta una señal, ingresará al procesamiento; en primer lugar, determinar qué detector detecta la línea negra.

Circuito de cableado del coche de seguimiento Arduino

Programa Arduino para seguimiento de automóviles:

int MotorRight1 = 5;
int MotorRight2 = 6; 
int MotorLeft1 = 10;
int MotorLeft2 = 11;
const int SensorLeft = 7; // pin para sensor a la izquierda
const int SensorMiddle = 4; // pin para sensor en el medio  
const int SensorRight = 3; // pin para sensor a la derecha 
int SL; // estado del sensor izquierdo
int SM; // estado del sensor medio
int SR; // estado correcto del sensor


Configuración de vacío ()
{
Serial.begin (9600);
pinMode (MotorRight1, OUTPUT); // pin 8 (PWM)
pinMode (MotorRight2, OUTPUT); // pin 9 (PWM)
pinMode (MotorLeft1, OUTPUT); // pin 10 (PWM)
pinMode (MotorLeft2, OUTPUT); // pin 11 (PWM)
pinMode (SensorLeft, INPUT); // define el sensor izquierdo
pinMode (SensorMiddle, INPUT); // define sensor medio  
pinMode (SensorRight, INPUT); // definir el sensor derecho
}


void loop ()
{
SL = digitalRead (SensorLeft);
SM = digitalRead (SensorMiddle);
SR = digitalRead (SensorRight);

if (SM == HIGH) // sensor medio en área negra
{
if (SL == LOW & SR == HIGH) // negro a la izquierda, blanco a la derecha, gire a la izquierda
{
digitalWrite (MotorRight1, BAJO);
digitalWrite (MotorRight2, ALTO);
analogWrite (MotorLeft1,0);
 

analogWrite (MotorLeft2,80);
}
else if (SR == LOW & SL == HIGH) // blanco a la izquierda, negro a la derecha, gire a la derecha
{
analogWrite (MotorRight1,0); // gira a la derecha 
analogWrite (MotorRight2,80); 
digitalWrite (MotorLeft1, BAJO); 
digitalWrite (MotorLeft2, ALTO);
}
else // blanco en ambos lados, en el futuro
{
digitalWrite (MotorRight1, BAJO); 
digitalWrite (MotorRight2, ALTO);
digitalWrite (MotorLeft1, BAJO); 
digitalWrite (MotorLeft2, ALTO);
analogWrite (MotorLeft1,200);
analogWrite (MotorLeft2,200); 
analogWrite (MotorRight1,200);
analogWrite (MotorRight2,200);
}
}
else // sensor medio en el área blanca
{
if (SL == LOW & SR == HIGH) // negro a la izquierda, blanco a la derecha, gire a la izquierda
{
digitalWrite (MotorRight1, BAJO); 
digitalWrite (MotorRight2, ALTO);
digitalWrite (MotorLeft1, BAJO); 
digitalWrite (MotorLeft2, BAJO);
}
else if (SR == LOW & SL == HIGH) // blanco a la izquierda, negro a la derecha, gire a la derecha
{
digitalWrite (MotorRight1, BAJO);
digitalWrite (MotorRight2, BAJO); 
digitalWrite (MotorLeft1, BAJO); 
digitalWrite (MotorLeft2, ALTO);
}
else // todo blanco, stop
{
digitalWrite (MotorRight1, ALTO);
digitalWrite (MotorRight2, BAJO); 
digitalWrite (MotorLeft1, ALTO); 
digitalWrite (MotorLeft2, BAJO) ;;
}}}

3) Coche inteligente ultrasónico para evitar obstáculos

Ultrasonic obstacle avoidance is easy to realize, simple in calculation. It is easy to control it in real time with practical measuring accuracy. Therefore, it has become a common method for obstacle avoidance. For the application method of ultrasonic, please refer to “Arduino ultrasonic ranging instruction”. Below is the connection diagram for ultrasonic obstacle avoidance:

1. Connection of motor

Motor 1 to L298N MOTOA

Motor 2 to L298N MOTOB

2. Power supply of L298N 
Use 1 contact of battery case of 6 cells of AA batteries to supply power for L298N motor driver module, another contact for Arduino main board. The + of the power supply for L298N motor driver module is connected to the VMS of L298N; the – to the GND. + 5V interface of L298N is not connected to anything.

3. The enable and turning function of the motor (with program)

int pinLB=5;	//  define pin 5 for left and back, connected to pin PWM5of the controller 
int pinLF=6;	// define pin 6 for left and front, connected to pin PWM6 of the controller board
int pinRB=10;	// define pin 10 for right and back, connected to pin PWM10 of the controller board
int pinRF=11;	// define pin 11 for right and front, connected to pin PWM11 of the controller board

4. Connection of the servo motor

myservo.attach(9);	// set servo motor output as pin 9(PWM)

5.Connection of the ultrasonic sensor

4 pins for this sensor
VCC to +5V
TRIQ signal input
ECHO signal output GND to GND

int inputPin = 13;  // define receiving pin for ultrasonic signal
int outputPin =12; // define sending pin for ultrasonic signal

Programa de autos inteligentes para evitar obstáculos por ultrasonidos (ARDUINO)

       L = izquierda 
       R = derecha 
 
       F = frente 
       B = espalda

*
/
#include <Servo.h>
int pinLB = 5; // definir el pin 6 como izquierda y atrás
int pinLF = 6; // definir el pin 9 como izquierdo y delantero
int pinRB = 10; // definir el pin 10 como derecho y volver
int pinRF = 11; // definir el pin 11 como derecho y delantero
int inputPin = 13; // definir pin de recepción para señal ultrasónica
int outputPin = 12; // definir el pin de envío para señal ultrasónica
int Fspeedd = 0; // velocidad en el futuro
int Rspeedd = 0; // velocidad yendo a la derecha
int Lspeedd = 0; // velocidad yendo a la izquierda
int directionn = 0; // F = 8 B = 2 L = 4 R = 6
Servo myservo; // establecer myservo
int delay_time = 250; // tiempo de establecimiento para el servomotor moviéndose hacia atrás

int Fgo = 8; // avanzando
int Rgo = 6; // yendo a la derecha
 int Lgo = 4; // yendo a la izquierda
int Bgo = 2; // yendo hacia atrás


Configuración de vacío ()
{
Serial.begin (9600); // definir la salida del motor
pinMode (pinLB, OUTPUT); // pin 5 (PWM)
pinMode (pinLF, OUTPUT); // pin 6 (PWM)
pinMode (pinRB, OUTPUT); // pin 10 (PWM)
pinMode (pinRF, OUTPUT); // pin 11 (PWM)

pinMode (inputPin, INPUT); // definir pin de recepción para señal ultrasónica
pinMode (outputPin, OUTPUT); // definir el pin de envío para señal ultrasónica
myservo.attach (9); // configura la salida del servomotor como pin 9 (PWM)
}
Avance nulo (int a) // en el futuro
{
digitalWrite (pinRB, BAJO); // movimiento del motor hacia la derecha y hacia atrás  
digitalWrite (pinRF, ALTO); 
digitalWrite (pinLB, BAJO); // movimiento del motor hacia la izquierda y hacia atrás
digitalWrite (pinLF, ALTO);
retraso (a * 100);
}


void right (int b) // girar a la derecha (1 rueda)
{
digitalWrite (pinRB, BAJO); // movimiento del motor hacia la derecha y hacia atrás   
digitalWrite (pinRF, ALTO); 
digitalWrite (pinLB, ALTO); 
digitalWrite (pinLF, ALTO);
retraso (b * 100);
}
vacío a la izquierda (int c) // giro a la izquierda (1 rueda)
{
digitalWrite (pinRB, ALTO); 
digitalWrite (pinRF, ALTO); 
digitalWrite (pinLB, BAJO); // movimiento del motor hacia la izquierda y hacia atrás
digitalWrite (pinLF, ALTO);
retraso (c * 100);
}
void turnR (int d) // girar a la derecha (2 ruedas)
{digitalWrite (pinRB, BAJO); // movimiento del motor hacia la derecha y hacia atrás
 digitalWrite (pinRF, ALTO); 
digitalWrite (pinLB, ALTO); 
digitalWrite (pinLF, BAJO); // movimiento del motor hacia la izquierda y hacia delante
retraso (d * 100);
}
void turnL (int e) // girar a la izquierda (2 ruedas)
{digitalWrite (pinRB, ALTO); 
digitalWrite (pinRF, BAJO); // movimiento del motor derecho y delantero
digitalWrite (pinLB, BAJO); // movimiento del motor hacia la izquierda y hacia atrás
digitalWrite (pinLF, ALTO);
retraso (e * 100);
}
void stopp (int f) // stop
{digitalWrite (pinRB, ALTO);
digitalWrite (pinRF, ALTO);
digitalWrite (pinLB, ALTO); 
digitalWrite (pinLF, ALTO); 
retraso (f * 100);
}
vacío atrás (int g) // retrocediendo
{digitalWrite (pinRB, ALTO); // movimiento del motor hacia la derecha y hacia atrás
digitalWrite (pinRF, BAJO); 
digitalWrite (pinLB, ALTO); // movimiento del motor hacia la izquierda y hacia atrás
digitalWrite (pinLF, BAJO);
retraso (g * 100);
}
detección de vacío () // mide 3 ángulos (0.90.179)
{
int delay_time = 250; // tiempo de establecimiento para el servomotor moviéndose hacia atrás
ask_pin_F (); // leer la distancia por adelantado
if (Fspeedd <10) // si la distancia es inferior a 10 cm
{
stopp (1); // borrar información de salida
atrás (2); // yendo hacia atrás durante 0.2 segundos
}
if (Fspeedd <25) // si la distancia es inferior a 25 cm
{
 stopp (1); // borrar información de salida
ask_pin_L (); // lee la distancia de la izquierda
delay (delay_time); // tiempo de establecimiento para el servo
ask_pin_R (); // leer la distancia a la derecha
delay (delay_time); // tiempo de establecimiento para el servo

if (Lspeedd> Rspeedd) // si la distancia de la izquierda es más que la de la derecha
{
directionn = Rgo; // yendo a la derecha
}
if (Lspeedd <= Rspeedd) // si la distancia de la izquierda es menor que la de la derecha
{
directionn = Lgo; // yendo a la izquierda
}


if (Lspeedd <10 && Rspeedd <10) // si ambas distancias son inferiores a 10 cm
{
directionn = Bgo; // yendo hacia atrás
}
}
else // si la distancia inicial es más de 25cm
{
directionn = Fgo; // en el futuro
}


}
void ask_pin_F () // medir la distancia por adelantado
{
myservo.write (90);
digitalWrite (outputPin, LOW); // ultrasónico envía baja tensión 2μs delayMicroseconds (2);
digitalWrite (outputPin, HIGH); // ultrasónico envía alto voltaje 10μs, al menos 10μs
delayMicroseconds (10);
digitalWrite (outputPin, LOW); // mantiene el envío de baja tensión
float Fdistance = pulseIn (inputPin, HIGH); // lee la diferencia horaria
Fdistance = Fdistance / 5.8 / 10; // convierte el tiempo en distancia (unidad: cm)
Serial.print ("Distancia F:"); // distancia de salida en cm 
Serial.println (Fdistance); // distancia de visualización
Fspeedd = Fdistance; // lee los datos de distancia en Fspeedd
}
void ask_pin_L () // mide la distancia a la izquierda
{
myservo.write (9);
 

retraso (delay_time);
digitalWrite (outputPin, LOW); // ultrasónico envía baja tensión 2μs
delayMicroseconds (2);
digitalWrite (outputPin, HIGH); // ultrasónico envía alta tensión 10μs, al menos 10μs
delayMicroseconds (10);
digitalWrite (outputPin, LOW); // mantiene el envío de baja tensión
flotante Ldistance = pulseIn (inputPin, HIGH); // lee la diferencia horaria
Ldistance = Ldistance / 5.8 / 10; // convierte el tiempo en distancia (unidad: cm)
Serial.print ("L distancia:"); // distancia de salida en cm
Serial.println (Ldistance); // distancia de visualización
Lspeedd = Ldistance; // lee los datos de distancia en Lspeedd
}
void ask_pin_R () // mide la distancia a la derecha
{
myservo.write (177); retraso (delay_time);
digitalWrite (outputPin, LOW); // ultrasónico envía baja tensión 2μs
delayMicroseconds (2);
digitalWrite (outputPin, HIGH); // ultrasónico envía alto voltaje 10μs, al menos 10μs
delayMicroseconds (10);
digitalWrite (outputPin, LOW); // mantener el envío de baja tensión
float Rdistance = pulseIn (inputPin, HIGH); // lee la diferencia horaria
Rdistance = Rdistance / 5,8 / 10; // convertir tiempo en distancia (unidad: cm)
Serial.print ("R distancia:"); // distancia de salida en cm
Serial.println (Rdistance); // distancia de visualización
Rspeedd = Rdistance; // lee los datos de distancia en Rspeedd
}


void loop ()
{
myservo.write (90); // restablecer el servomotor y prepararlo para la próxima medición
detección(); // medir el ángulo y decidir qué dirección mover
if (directionn == 2) // if directionn = 2
{
volver (8); // ir hacia atrás
turnL (2); // mueve ligeramente hacia la izquierda para evitar quedar atrapado en el callejón sin salida
Serial.print ("Reverse"); // dirección de visualización (hacia atrás)
}
if (directionn == 6) // if direction = 6
{
espalda (1);
turnR (6); // gire a la derecha
Serial.print ("derecha"); // dirección de visualización (derecha)
 

}
if (directionn == 4) // if direction = 4
{
espalda (1);
turnL (6); // gire a la izquierda
Serial.print ("izquierda"); // dirección de visualización (izquierda)
}
if (directionn == 8) // if direction = 8
{
avance (1); // adelante
Serial.print ("Advance"); // dirección de visualización (adelante)
Serial.print ("");
}
}

4) Coche inteligente teledirigido infrarrojo

Antes del experimento:
1. Coloque la biblioteca de funciones IRremote en el directorio de bibliotecas de Arduino.
2. Abra IrReceive.pde para adquirir el código de su control remoto por infrarrojos (IRcode se mostrará en Serial Monitor), escriba IRcode y modifíquelo en su código IR en el programa.

/ *
*IRRemote code test
*Example 1.2: display the type of IR protocol such as  NEC, Sony SIRC, Philips RC5, Philips RC6
*/

#include <IRremote.h>	// call IRRemote function library
const int irReceiverPin = 2;	// set pin 2 as IR receiver signal  OUTPUT


IRrecv irrecv(irReceiverPin);		// set  IRrecv to receive IR signal 
decode_results results;	//  decode result will be put into the variable of the result in the  decode_results


void setup()
{
Serial.begin(9600);// set communication rate at  9600 bps 
irrecv.enableIRIn();// start IR decoding
}


//  display the type of IR protocol
void showIRProtocol(decode_results *results)
{
Serial.print("Protocol: ");


// determine  the type of IR protocol 
switch(results->decode_type) { case NEC:
Serial.print("NEC"); break;
case SONY: Serial.print("SONY"); break;
caso RC5: Serial.print ("RC5"); descanso;
caso RC6: Serial.print ("RC6"); descanso;
defecto:
Serial.print ("codificación desconocida");
}


// código de IR de impresión en serie al puerto serie Serial.print (", irCode:");
Serial.print (results-> value, HEX); // código IR
Serial.print (", bits:");
Serial.println (resultados-> bits); // código IR bit
}


void loop ()
{
if (irrecv.decode (& results)) {// finaliza la decodificación, recibe la señal IR 
showIRProtocol (& results); // muestra el tipo de protocolo IR
irrecv.resume (); // continuar recibiendo la señal IR que viene después
}
}

Reemplace el código IR en el programa de la parte de control IR con el código del programa inteligente de control remoto inteligente IR de la prueba

Programa de coche inteligente a control remoto IR

#include <IRremote.h> int RECV_PIN = 2;
int pinLB = 5; // definir pin para I1 
int pinLF = 6; // definir pin para I2 
int pinRB = 10; // definir pin para I3 
int pinRF = 11; // definir pin para I4 
// ****** Parte de control IR ******** largo advence = 0x00EF807F; largo atrás = 0x00EFA05F;
parada larga = 0x00EF906F; 
largo a la izquierda = 0x00EF00FF;
largo derecho = 0x00EF40BF;

IRrecv irrecv (RECV_PIN); 
decode_results results;
volcado de vacío (resultados decode_results *)

{int count = results-> rawlen;
if (results-> decode_type == UNKNOWN)
{
Serial.println ("No se pudo decodificar el mensaje");
}
más
{
if (results-> decode_type == NEC)
{
Serial.print ("Decoded NEC:");
}
else if (results-> decode_type == SONY)
{
Serial.print ("Decoded SONY:");
}
else if (results-> decode_type == RC5)
{
Serial.print ("Decoded RC5:");
}
else if (results-> decode_type == RC6)
{
Serial.print ("Decoded RC6:");
}
Serial.print (results-> value, HEX);
Serial.print ("("); 
Serial.print (results-> bits, DEC);
Serial.println ("bits)");
}
Serial.print ("Raw (");
Serial.print (count, DEC); 
Serial.print ("):");

para (int i = 0; i <contar; i ++)
{
if ((i% 2) == 1) {
Serial.print (results-> rawbuf [i] * USECPERTICK, DEC);
}
más
{
Serial.print (- (int) results-> rawbuf [i] * USECPERTICK, DEC);
}
Serial.print ("");
}
Serial.println ("");
}


Configuración de vacío ()
{
pinMode (RECV_PIN, INPUT);
pinMode (pinLB, OUTPUT); pinMode (pinLF, OUTPUT);


pinMode (pinRB, OUTPUT); pinMode (pinRF, OUTPUT);


Serial.begin (9600);
irrecv.enableIRIn (); // Inicie el receptor
}


int on = 0;
unsigned long last = millis ();


void loop ()
{
if (irrecv.decode (y resultados))
{
// Si ha sido al menos 1/4 de segundo desde la última
// recibido IR, alternar el relevador if (millis () - last> 250)
{
on =! on;
// digitalWrite (8, encendido? ALTO: BAJO);
digitalWrite (13, encendido? ALTO: BAJO);
volcado (y resultados);
}
if (results.value == advence)
{digitalWrite (pinRB, LOW); // motor funcionando correctamente 
digitalWrite (pinRF, ALTO); 
digitalWrite (pinLB, LOW); // motor a la izquierda 
digitalWrite (pinLF, HIGH);}


if (results.value == back)



{digitalWrite (pinRB, HIGH); // motor va a la derecha y ATRÁS 
digitalWrite (pinRF, BAJO);}


if (results.value == left)
{digitalWrite (pinRB, LOW); // motor funcionando correctamente y STOP
digitalWrite (pinRF, ALTO); 
digitalWrite (pinLB, HIGH); // motor a la izquierda 
digitalWrite (pinLF, BAJO);}



if (results.value == right)
{digitalWrite (pinRB, HIGH); // motor funcionando correctamente 
digitalWrite (pinRF, BAJO); 
digitalWrite (pinLB, HIGH); // motor que va a la izquierda y STOP 
digitalWrite (pinLF, HIGH);}


if (results.value == stop)
 

{
digitalWrite (pinRB, HIGH); // motor funcionando correctamente y STOP
digitalWrite (pinRF, ALTO);
digitalWrite (pinLB, HIGH); // motor que va a la izquierda y STOP 
digitalWrite (pinLF, ALTO);

}


last = millis ();
irrecv.resume (); // Recibe el siguiente valor
}
}

5. Coche inteligente Bluetooth controlado por teléfono móvil

keyestudio El módulo inalámbrico Bluetooth Bluetooh XBee HC-06 adopta el diseño XBEE. Tiene características de tamaño compacto, compatible con escudo XBEE, y adecuado para varios sistemas de 3.3V MCU. El módulo puede usar el comando AT para establecer la velocidad en baudios y el modo maestro / esclavo. La configuración predeterminada es la velocidad en baudios 9600, la contraseña de parchado 1234, el modo esclavo.

Viene con una antena de a bordo eficiente. La antena expuesta garantiza una mejor calidad de señal y una mayor distancia de transmisión. El puerto serie transparente se puede usar para emparejarse con varios adaptadores Bluetooth, teléfonos Bluetooth. El diseño humanizado ofrece comodidad para el desarrollo secundario. Después de la prueba, se sabe que el módulo es adecuado para usar con todos los adaptadores Bluetooth del mercado (PC y teléfonos con Bluetooth).

Ahora, pasemos al programa. Ingresaré «r» y después de que Arduino reciba mi comando «r», el LED en el PIN 13 parpadeará e imprimirá el carácter de «teclas». El programa es el siguiente:

char val;
int ledpin = 13; Configuración de vacío ()
{
Serial.begin (9600); pinMode (ledpin, OUTPUT);
}
void loop ()
{
val = Serial.read (); if (val == 'r')
{
digitalWrite (ledpin, HIGH); delay ((500); digitalWrite (ledpin, LOW); delay (500); Serial.println ("keyes");
}
}

Ahora, veamos cómo hacer que el Smart Car programable avance, retroceda, gire a la izquierda o derecha a través del control remoto bluetooth arduino. Hay dos formas de controlar el movimiento del automóvil inteligente, por computadora o teléfono móvil (El sistema operativo del teléfono debe ser compatible con Android 2.3.7 o una versión posterior y la computadora debe llevar Bluetooth). El teléfono se debe emparejar con el bluetooth car durante el uso inicial (no es necesario ubicar el dispositivo inalámbrico después del primer emparejamiento). Por favor, compruebe los siguientes pasos para el primer paring:

1. No olvides activar la función bluetooth del teléfono. El software recordará a los usuarios que activen la función Bluetooth cuando se inicie el software.
2. Conecte el dispositivo bluetooth de acuerdo con las instrucciones de texto en la foto. Escanee y vincule con un dispositivo bluetooth; de lo contrario, no podrá conectarse con el automóvil inteligente.
3. El código para emparejar con el auto inteligente es «1234», ¡pruébalo!

Descargue la APLICACIÓN Bluetooth aquí .

El programa para el coche inteligente programable con control remoto Bluetooth Arduino es el siguiente:

int MotorRight1 = 5;
int MotorRight2 = 6; int MotorLeft1 = 10; int MotorLeft2 = 11;



Configuración de vacío ()
{
Serial.begin (9600);
pinMode (MotorRight1, OUTPUT); // pin 5 (PWM) pinMode (MotorRight2, OUTPUT); // pin 6 (PWM) pinMode (MotorLeft1, OUTPUT); // pin 10 (PWM) pinMode (MotorLeft2, OUTPUT); // pin 11 (PWM)
}


void go () // seguir adelante
{
digitalWrite (MotorRight1, BAJO); digitalWrite (MotorRight2, ALTO); digitalWrite (MotorLeft1, BAJO); digitalWrite (MotorLeft2, ALTO);

}


void left () // gira a la derecha
{
digitalWrite (MotorRight1, ALTO); digitalWrite (MotorRight2, BAJO); digitalWrite (MotorLeft1, BAJO); digitalWrite (MotorLeft2, ALTO);


}
void right () // gira a la izquierda 
{
digitalWrite (MotorRight1, BAJO); digitalWrite (MotorRight2, ALTO); digitalWrite (MotorLeft1, ALTO); digitalWrite (MotorLeft2, BAJO);
}
void stop () // stop 
{
digitalWrite (MotorRight1, BAJO); digitalWrite (MotorRight2, BAJO);
 digitalWrite (MotorLeft1, BAJO);
 digitalWrite (MotorLeft2, BAJO);


}
void atrás () // ir hacia atrás
{
digitalWrite (MotorRight1, ALTO); digitalWrite (MotorRight2, BAJO); digitalWrite (MotorLeft1, ALTO); digitalWrite (MotorLeft2, BAJO) ;;

}


void loop ()
{
char val = Serial.read (); Serial.write (val);
if (-1! = val) {
if ('U' == val)
ir();
else if ('L' == val) left ();
else if ('R' == val) right ();
else if ('D' == val) atrás ();
else if ('S' == val) stop (); retraso (500);
}
más
{
//detener(); retraso (500);
}
}

6) 4 en 1 (seguimiento de línea, evitación de obstáculos, control IR, control bluetooth) programa

// ******************************
#include <IRremote.h>
#include <Servo.h>
// *********************** define el pin del motor ********************** ***
int MotorRight1 = 5;
int MotorRight2 = 6;
int MotorLeft1 = 10;
int MotorLeft2 = 11;
contador int = 0;
const int irReceiverPin = 2; // establecer el pin 2 como señal del receptor IR OUTPUT
char val;
// *********************** establece el IRcode a partir del resultado de la prueba ****************** *******
IRfront largo = 0x00FF629D; // código para seguir adelante
IRback largo = 0x00FFA857; // yendo hacia atrás
largo IRturnright = 0x00FFC23D; // dobla a la derecha
long IRturnleft = 0x00FF22DD; // girar a la izquierda
IRstop largo = 0x00FF02FD; // detener
largo IRcny70 = 0x00FF6897; // CNY70 aoto-movingmode
IRAutorun largo = 0x00FF9867; // modo aoto-moving ultrasónico
long IRturnsmallleft = 0x00FFB04F;
// ************************* define pin CNY70 ******************** ****************
const int SensorLeft = 7; // pin de entrada para sensor izquierdo
const int SensorMiddle = 4; // pin de entrada para sensor medio
const int SensorRight = 3; // pin de entrada para el sensor derecho
int SL; // estado del sensor izquierdo
int SM; // estado del sensor medio
int SR; // estado correcto del sensor
IRrecv irrecv (irReceiverPin); // establece IRrecv para recibir señal IR
decode_results results; // el resultado de decodificación se colocará en la variable del resultado en
// ************************* pin de definición para ultrasonido ******************* ***********
int inputPin = 13; // define la señal de ultrasonido que recibe el pin rx
int outputPin = 12; // define la señal ultrasónica enviando pin'tx
int Fspeedd = 0; // distancia por adelantado
int Rspeedd = 0; // distancia a la derecha
int Lspeedd = 0; // distancia a la izquierda
int directionn = 0; // F = 8 B = 2 L = 4 R = 6
Servo myservo; // establecer myservo
int delay_time = 250; // tiempo de establecimiento para el servomotor moviéndose hacia atrás
int Fgo = 8; // avanzando
int Rgo = 6; // yendo a la derecha
int Lgo = 4; // yendo a la izquierda
int Bgo = 2; // yendo hacia atrás
// ************************************************ ********************(PREPARAR)
Configuración de vacío ()
{
Serial.begin (9600);
pinMode (MotorRight1, OUTPUT); // pin 8 (PWM)
pinMode (MotorRight2, OUTPUT); // pin 9 (PWM)
pinMode (MotorLeft1, OUTPUT); // pin 10 (PWM)
pinMode (MotorLeft2, OUTPUT); // pin 11 (PWM)
irrecv.enableIRIn (); // iniciar la decodificación IR
pinMode (SensorLeft, INPUT); // define el sensor izquierdo
pinMode (SensorMiddle, INPUT); // define sensor medio
pinMode (SensorRight, INPUT); // definir el sensor derecho
digitalWrite (2, ALTO);
pinMode (inputPin, INPUT); // definir pin de recepción para señal ultrasónica
pinMode (outputPin, OUTPUT); // definir el pin de envío para señal ultrasónica
myservo.attach (9); // establece la salida del servomotor como pin 5 (PWM)
}
// ************************************************ ******************(Vacío)
void advance (int a) // seguir adelante
{
digitalWrite (MotorRight1, BAJO);
digitalWrite (MotorRight2, ALTO);
digitalWrite (MotorLeft1, BAJO);
digitalWrite (MotorLeft2, ALTO);
retraso (a * 100);
}
void right (int b) // girar a la derecha (1 rueda)
{
digitalWrite (MotorLeft1, BAJO);
digitalWrite (MotorLeft2, ALTO);
digitalWrite (MotorRight1, BAJO);
digitalWrite (MotorRight2, BAJO);
retraso (b * 100);
}
vacío a la izquierda (int c) // giro a la izquierda (1 rueda)
{
digitalWrite (MotorRight1, BAJO);
digitalWrite (MotorRight2, ALTO);
digitalWrite (MotorLeft1, BAJO);
digitalWrite (MotorLeft2, BAJO);
retraso (c * 100);
}
void turnR (int d) // girar a la derecha (2 ruedas)
{
digitalWrite (MotorRight1, ALTO);
digitalWrite (MotorRight2, BAJO);
digitalWrite (MotorLeft1, BAJO);
digitalWrite (MotorLeft2, ALTO);
retraso (d * 100);
}
void turnL (int e) // girar a la izquierda (2 ruedas)
{
digitalWrite (MotorRight1, BAJO);
digitalWrite (MotorRight2, ALTO);
digitalWrite (MotorLeft1, ALTO);
digitalWrite (MotorLeft2, BAJO);
retraso (e * 100);
}
void stopp (int f) // stop
{
digitalWrite (MotorRight1, BAJO);
digitalWrite (MotorRight2, BAJO);
digitalWrite (MotorLeft1, BAJO);
digitalWrite (MotorLeft2, BAJO);
retraso (f * 100);
}
vacío atrás (int g) // ir hacia atrás
{
digitalWrite (MotorRight1, ALTO);
digitalWrite (MotorRight2, BAJO);
digitalWrite (MotorLeft1, ALTO);
digitalWrite (MotorLeft2, BAJO) ;;
retraso (g * 100);
}
detección de vacío () // mide 3 ángulos (0.90.179)
{
int delay_time = 250; // tiempo de establecimiento para el servomotor moviéndose hacia atrás
ask_pin_F (); // lee la distancia por adelantado
if (Fspeedd <10) // si la distancia es inferior a 10 cm
{
stopp (1); // borrar información de salida
espalda (2); // retrocediendo por 0.2 segundos
}
if (Fspeedd <15) // si la distancia es inferior a 25 cm
{
stopp (1); // borrar información de salida
ask_pin_L (); // lee la distancia a la izquierda
retraso (delay_time); // tiempo de establecimiento para el servo
ask_pin_R (); // lee la distancia a la derecha
retraso (delay_time); // tiempo de establecimiento para el servo
if (Lspeedd> Rspeedd) // si la distancia de la izquierda es más que la de la derecha
{
directionn = Lgo; // ve a la izquierda
}
if (Lspeedd <= Rspeedd) // si la distancia de la izquierda es menor que la de la derecha
{
directionn = Rgo; // yendo a la derecha
}
if (Lspeedd <10 && Rspeedd <10) // si ambas distancias son inferiores a 10 cm
{
directionn = Bgo; // yendo hacia atrás
}
}
else // si la distancia inicial es más de 25cm
{
directionn = Fgo; // avanzando
}
}
// ************************************************ *****************************
void ask_pin_F () // medir la distancia por adelantado
{
myservo.write (90);
retraso (delay_time);
digitalWrite (outputPin, LOW); // ultrasónico envía baja tensión 2μs
delayMicroseconds (2);
digitalWrite (outputPin, HIGH); // ultrasónico envía alto voltaje 10μs, al menos 10μs
delayMicroseconds (10);
digitalWrite (outputPin, LOW); // mantener el envío de baja tensión
float Fdistance = pulseIn (inputPin, HIGH); // lee la diferencia horaria
Fdistance = Fdistance / 5,8 / 10; // convertir tiempo en distancia (unidad: cm)
Serial.print ("Fdistance:"); // distancia de salida en cm
Serial.println (Fdistance); // distancia de visualización
Fspeedd = Fdistance; // lee los datos de distancia en Fspeedd
}
// ************************************************ *****************************
void ask_pin_L () // mide la distancia a la izquierda
{
myservo.write (177);
retraso (delay_time);
digitalWrite (outputPin, LOW); // ultrasónico envía baja tensión 2μs
delayMicroseconds (2);
digitalWrite (outputPin, HIGH); // ultrasónico envía alto voltaje 10μs, al menos 10μs
delayMicroseconds (10);
digitalWrite (outputPin, LOW); // mantener el envío de baja tensión
flotante Ldistance = pulseIn (inputPin, HIGH); // lee la diferencia horaria
Ldistance = Ldistance / 5.8 / 10; // converttimetimedistance (unidad: cm)
Serial.print ("Ldistance:"); // distancia de salida en cm
Serial.println (Ldistance); // distancia de visualización
Lspeedd = Ldistance; // lee los datos de distancia en Lspeedd
}
// ************************************************ *****************************
void ask_pin_R () // mide la distancia a la derecha
{
myservo.write (5);
retraso (delay_time);
digitalWrite (outputPin, LOW); // ultrasónico envía baja tensión 2μs
delayMicroseconds (2);
digitalWrite (outputPin, HIGH); // ultrasónico envía alto voltaje 10μs, al menos 10μs
delayMicroseconds (10);
digitalWrite (outputPin, LOW); // mantener el envío de baja tensión
float Rdistance = pulseIn (inputPin, HIGH); // lee la diferencia horaria
Rdistance = Rdistance / 5,8 / 10; // convertir tiempo en distancia (unidad: cm)
Serial.print ("Rdistance:"); // distancia de salida en cm
Serial.println (Rdistance); // distancia de visualización
Rspeedd = Rdistance; // lee los datos de distancia en Rspeedd
}
// ************************************************ ******************************(LAZO)
void loop ()
{
SL = digitalRead (SensorLeft);
SM = digitalRead (SensorMiddle);
SR = digitalRead (SensorRight);
performCommand ();
// ************************************************ *** modo de control remoto normal
if (irrecv.decode (y resultados))
{// finalizar la decodificación, recibir señal IR
/ ************************************************* ********************** /
if (results.value == IRfront) // seguir adelante
{
avance (10); // seguir adelante
}
/ ************************************************* ********************** /
if (results.value == IRback) // ir hacia atrás
{
volver (5); // ir hacia atrás
}
/ ************************************************* ********************** /
if (results.value == IRturnright) // gira a la derecha
{
derecha (5); // dobla a la derecha
}
/ ************************************************* ********************** /
if (results.value == IRturnleft) // gire a la izquierda
{
izquierda (5); // girar a la izquierda);
}
/ ************************************************* ********************** /
if (results.value == IRstop) // stop
{
digitalWrite (MotorRight1, BAJO);
digitalWrite (MotorRight2, BAJO);
digitalWrite (MotorLeft1, BAJO);
digitalWrite (MotorLeft2, BAJO);
}
// ************************************************ ****** modo línea blanco y negro
if (results.value == IRcny70)
{
mientras (IRcny70)
{
SL = digitalRead (SensorLeft);
SM = digitalRead (SensorMiddle);
SR = digitalRead (SensorRight);
if (SM == HIGH) // sensor medio en área negra
{
if (SL == LOW & SR == HIGH) // negro a la izquierda, blanco a la derecha, gire a la izquierda
{
digitalWrite (MotorRight1, BAJO);
digitalWrite (MotorRight2, ALTO);
digitalWrite (MotorLeft1, BAJO);
digitalWrite (MotorLeft2, BAJO);
}
else if (SR == LOW & SL == HIGH) // blanco a la izquierda, negro a la derecha, gire a la derecha
{
digitalWrite (MotorLeft1, BAJO);
digitalWrite (MotorLeft2, ALTO);
digitalWrite (MotorRight1, BAJO);
digitalWrite (MotorRight2, BAJO);
}
else // blanco en ambos lados, en el futuro
{
digitalWrite (MotorRight1, BAJO);
digitalWrite (MotorRight2, ALTO);
digitalWrite (MotorLeft1, BAJO);
digitalWrite (MotorLeft2, ALTO);
}
}
else // sensor medio en el área blanca
{
if (SL == LOW & SR == HIGH) // negro a la izquierda, blanco a la derecha, gire a la izquierda
{
digitalWrite (MotorRight1, BAJO);
digitalWrite (MotorRight2, ALTO);
digitalWrite (MotorLeft1, BAJO);
digitalWrite (MotorLeft2, BAJO);
}
else if (SR == LOW & SL == HIGH) // blanco a la izquierda, negro a la derecha, gire a la derecha
{
digitalWrite (MotorLeft1, BAJO);
digitalWrite (MotorLeft2, ALTO);
digitalWrite (MotorRight1, BAJO);
digitalWrite (MotorRight2, BAJO);
}
else // todo blanco, stop
{
digitalWrite (MotorRight1, BAJO);
digitalWrite (MotorRight2, BAJO);
digitalWrite (MotorLeft1, BAJO);
digitalWrite (MotorLeft2, BAJO);
}
}
if (irrecv.decode (y resultados))
{
irrecv.resume ();
Serial.println (results.value, HEX);
if (results.value == IRstop)
{
digitalWrite (MotorRight1, ALTO);
digitalWrite (MotorRight2, ALTO);
digitalWrite (MotorLeft1, ALTO);
digitalWrite (MotorLeft2, ALTO);
descanso;
}
}
}
results.value = 0;
}
// ************************************************ ******** modo ultrasónico de movimiento automático
if (results.value == IRAutorun)
{
mientras (IRAutorun)
{
myservo.write (90); // restablecer el servomotor y prepararlo para la próxima medición
detección(); // medir el ángulo y decidir qué dirección mover
if (directionn == 8) // if directionn = 8
{
if (irrecv.decode (y resultados))
{
irrecv.resume ();
Serial.println (results.value, HEX);
if (results.value == IRstop)
{
digitalWrite (MotorRight1, BAJO);
digitalWrite (MotorRight2, BAJO);
digitalWrite (MotorLeft1, BAJO);
digitalWrite (MotorLeft2, BAJO);
descanso;
}
}
results.value = 0; avance (1); // avanzando
Serial.print ("Advance"); // dirección de visualización (adelante)
Serial.print ("");
}
if (directionn == 2) // if directionn = 2
{
if (irrecv.decode (y resultados))
{
irrecv.resume ();
Serial.println (results.value, HEX);
if (results.value == IRstop)
{
digitalWrite (MotorRight1, BAJO);
digitalWrite (MotorRight2, BAJO);
digitalWrite (MotorLeft1, BAJO);
digitalWrite (MotorLeft2, BAJO);
descanso;
}
}
results.value = 0; 
espalda (2); // yendo hacia atrás
turnL (3); // mueve ligeramente hacia la izquierda para evitar quedar atrapado en el callejón sin salida
Serial.print ("Reverse"); // dirección de visualización (hacia atrás)
}
if (directionn == 6) // if direction = 6
{
if (irrecv.decode (y resultados))
{
irrecv.resume ();
Serial.println (results.value, HEX);
if (results.value == IRstop)
{
digitalWrite (MotorRight1, BAJO);
digitalWrite (MotorRight2, BAJO);
digitalWrite (MotorLeft1, BAJO);
digitalWrite (MotorLeft2, BAJO);
descanso;
}
}
results.value = 0;
espalda (2);
turnR (3); // dobla a la derecha
Serial.print ("derecha"); // dirección de visualización (derecha)
}
if (directionn == 4) // if direction = 4
{
if (irrecv.decode (y resultados))
{
irrecv.resume ();
Serial.println (results.value, HEX);
if (results.value == IRstop)
{
digitalWrite (MotorRight1, BAJO);
digitalWrite (MotorRight2, BAJO);
digitalWrite (MotorLeft1, BAJO);
digitalWrite (MotorLeft2, BAJO);
descanso;
}
}
results.value = 0; 
espalda (2); 
turnL (3); // girar a la izquierda
Serial.print ("izquierda"); // dirección de visualización (izquierda)
}
if (irrecv.decode (y resultados))
{
irrecv.resume ();
Serial.println (results.value, HEX);
if (results.value == IRstop)
{
digitalWrite (MotorRight1, BAJO);
digitalWrite (MotorRight2, BAJO);
digitalWrite (MotorLeft1, BAJO);
digitalWrite (MotorLeft2, BAJO);
descanso;
}
}
}
results.value = 0;
}
/ ************************************************* ********************** /
más
{
digitalWrite (MotorRight1, BAJO);
digitalWrite (MotorRight2, BAJO);
digitalWrite (MotorLeft1, BAJO);
digitalWrite (MotorLeft2, BAJO);
}
irrecv.resume (); // seguir recibiendo la señal de IR que viene después
}
}
void performCommand ()
{if (Serial.available ())
{val = Serial.read ();
}
if (val == 'U') {// Reenviar
avance (1);
} else if (val == 'D') {// Atrás
espalda (1);
} else if (val == 'R') {// Derecha
turnR (1);
} else if (val == 'L') {// Izquierda
turnL (1);
} else if (val == 'S') {// Stop
stopp (1);
}
}

Recursos

Vídeo

http://www.keyestudio.com/wp/2016/08/ks0191-keyestudio-smart-small-turtle-robot-demonstation-video/

Ficha de datos

PDF: https://drive.google.com/open?id=1bXG8hsNdW6lCYMWY5sBeL0hOEzsnWBlT

APLICACIÓN: https://drive.google.com/open?id=1PjW65Lc6j2oMf0lhUWpPhhwsGY4YTsZ9

Códigos: https://drive.google.com/open?id=1ECizLcFkTWEgi6dwQx2Z2ahYoUqpG4Og

Biblioteca: https://drive.google.com/open?id=1IVq0xOV1IwXGpMXT-YprNULkJizPsnIE