En los últimos días, tengo tiempo para hacer un auto con control remoto Bluetooth controlado por un teléfono móvil, y finalmente me di cuenta hoy. Comparta el proceso y la experiencia con usted.
Sin más preámbulos, vaya
primero al mapa físico . La lista de componentes del proyecto
1. Un tesoro compra un chasis de automóvil inteligente (mi automóvil es de cuatro ruedas, por lo que hay cuatro motores, dos placas de acrílico y algunos tornillos accesorios)
2. Módulo L298n Dos (un 298 controla dos motores)
3. Módulo Bluetooth HC-06
4, caja de batería y batería 18650 3
5, sistema mínimo de computadora de un solo chip
6, línea Dupont al menos 12, por supuesto, cuanto más, mejor
7, varios cables ( Para conectar el motor, y la caja de la batería está conectada al L298N y al microcontrolador)
En segundo lugar, el proceso de producción En
primer lugar, primero comprendamos el cableado de L298N, también me obligaron durante mucho tiempo, de todos modos, estará a tientas, las tiendas generales tienen información. Luego use el módulo Bluetooth. Después de obtener el módulo Bluetooth, si hay una placa de desarrollo (si no, use el quemador del microcontrolador), primero conecte TXD a TXD, RXD a RXD, abra el asistente serial de la computadora para comunicarse con Bluetooth, abra AT , Enviar conjunto de comandos AT, como establecer la velocidad en baudios, cambiar el nombre, cambiar la contraseña de emparejamiento. Pero cuando se conecta al microcontrolador a través de Bluetooth, es TXD conectado a RXD. La última es que a menudo golpeé la pared cuando estaba cableando. Por ejemplo, si cree que el cable conectado en realidad no está conectado, no funciona en absoluto. Todavía tiene que tomar el multímetro B para saberlo.
Debido a que olvidé comprar la caja de batería, la conecté con 12 V CC, lo que provocó que el automóvil del control remoto arrastrara el cable.
Tercero, la imagen física
(remolcando el auto con el cable y el tesoro cargando, pero no tenía energía)
La información incluye cierta información de L298N, así como el manual de Bluetooth (solo mire el conjunto de instrucciones AT) y el programa fuente.
/ Teléfono móvil Bluetooth remoto coche de control APP se pueden encontrar en el mercado de aplicaciones Bluetooth de serie asistente puerto
Zuozhuanyouzhuan aproximadamente 90 grados es mi tracción a las cuatro ruedas, si es sólo un L298N a continuación, poner el cinturón de borrado 2
PWM tiene una velocidad de diez /
#include <reg52.h>
#define Left_moto2_pwm P0_4 // Conectar al terminal de habilitación ENA del módulo de transmisión, ingresar la señal PWM para ajustar la velocidad de la rueda trasera izquierda
#define Right_moto2_pwm P0_5 // Conectar al módulo de transmisión ENB rueda trasera derecha
#define Left_moto_pwm P1_4 // Conectar al terminal de habilitación ENA del módulo de transmisión, entrada Velocidad de ajuste de la señal PWM rueda delantera izquierda
#define Right_moto_pwm P1_5 // Conecte al módulo de accionamiento ENB rueda delantera derecha
#define uchar unsigned char
#define uint unsigned int
sbit P0_4 = P0 ^ 4; // define P0_4
sbit P0_5 = P0 ^ 5; // define P0_5
sbit P1_4 = P1 ^ 4; // define P1_4
sbit P1_5 = P1 ^ 5; // define P1_5
/ Definición de IO del accionamiento del motor /
sbit IN1 = P1 ^ 2; // es 1 rueda izquierda del motor de rotación inversa
sbit IN2 = P1 ^ 3; // es 1 rueda izquierda del motor de rotación delantera
sbit IN3 = P1 ^ 6; // es 1 Motor derecho gira la rueda delantera
sbit IN4 = P1 ^ 7; // es 1 Motor derecho gira la rueda delantera
/ * sbit EN1 = P1 ^ 4; // es 1 Motor izquierdo habilita
sbit EN2 = P1 ^ 5; // Habilitar para 1 motor derecho * /
sbit IN5 = P0 ^ 2; // es 1 rotación
hacia atrás del motor izquierdo sbit IN6 = P0 ^ 3; // es 1 rotación hacia adelante del motor izquierdo
sbit IN7 = P0 ^ 6; // es 1 rotación hacia adelante del motor derecho rueda
IN8 sbit = P0 ^ 7; // 1 es un derecho trasero inversión del motor de rueda
/ * sbit EN3 = P0 ^ 4 ; // permitir que el motor a una rueda trasera izquierda
EN4 sbit = P0 ^ 5; // 1 es un motor derecha Habilitar la rueda trasera * /
bit Right_moto_stop = 1;
bit Left_moto_stop = 1;
unsigned int time = 0;
int pwm = 1;
#define left_motor_en EN1 = 1 // Habilitación del motor izquierdo
#define left_motor_stops EN1 = 0 // Parada del motor izquierdo
#define right_motor_en EN2 = 1 // Habilitación del motor derecho
#define right_motor_stops EN2 = 0 // Parada del motor derecho
#define left_motor2_en EN3 = 1 // Después de habilitar el motor izquierdo
#define left_motor2_stops EN3 = 0 // Después de detener el motor izquierdo
#define right_motor2_en EN4 = 1 // Después de habilitar el motor derecho
#define right_motor2_stops EN4 = 0 // Después de detener el motor derecho
#define left_motor_go IN1 = 0, IN2 = 1 // motor izquierdo hacia adelante
#define left_motor_back IN1 = 1, IN2 = 0 // motor izquierdo hacia atrás
#define right_motor_go IN3 = 1, IN4 = 0 // motor derecho hacia adelante
#define right_motor_back IN3 = 0, IN4 = 1 // Motor derecho marcha atrás
#define left_motor2_go IN5 = 0, IN6 = 1 // motor izquierdo hacia adelante
#define left_motor2_back IN5 = 1, IN6 = 0 // motor izquierdo hacia atrás
#define right_motor2_go IN7 = 1, IN8 = 0 // motor derecho hacia adelante
#define right_motor2_back IN7 = 0, IN8 = 1 // Motor derecho marcha atrás
unsigned char pwm_val_left = 0; // Definición variable
unsigned char push_val_left = 0; // Ciclo de trabajo izquierdo del motor N / 10
unsigned char pwm_val_right = 0;
unsigned char push_val_right = 0; // Ciclo de trabajo derecho del motor N / 10
retraso nulo (uint z)
{
uint x, y;
para (x = z; x> 0; x–)
para (y = 114; y> 0; y–);
}
// Inicialización de Bluetooth
anulada UART_INIT ()
{
SM0 = 0;
SM1 = 1; // Modo de trabajo del puerto serie 1
REN = 1; // Permitir que el puerto serie reciba
EA = 1; // Abra la interrupción total
ES = 1; // Abra la interrupción del puerto serie
TMOD = 0x20; /// modo de recarga automática de 8 bits
TH1 = 0xfd;
TL1 = 0xfd; // 9600 baudios
TR1 = 1; // iniciar temporizador 1
}
/ ************************************************* *********************** /
void run (void) // función de regulación de velocidad pwm
{
push_val_left = pwm; // parámetro de regulación PWM 1-10 1 es El más lento, 10 es el más rápido. Cambiar este valor puede cambiar su velocidad
push_val_right = pwm; // Los parámetros de ajuste de PWM 1-10 1 es el más lento, 10 es el más rápido. Cambiar este valor puede cambiar su velocidad
si (pwm10) pwm = 0;
si (pwm0 && pwm <0) pwm = 0;
}
/ ************************************************* ************************************************************ /
/ el PWM modulada la velocidad del motor /
/ ********************************************************* ************************************************** * /
/ * Regulación de velocidad del motor del lado izquierdo * /
/ * Ajuste el valor de push_val_left para cambiar la velocidad del motor, ciclo de trabajo * /
void pwm_out_left_moto (void)
{
if (Left_moto_stop)
{
if (pwm_val_left <= push_val_left)
{Left_moto_pwm = 1;
Left_moto2_p ;}
else
{Left_moto_pwm = 0; Left_moto2_pwm = 0;}
if (pwm_val_left> = 10)
pwm_val_left = 0;
}
else {Left_moto_pwm = 0; Left_moto2_pwm = 0; }
}
/ *********************************************** ****************** /
/右侧 电机 调速/
void pwm_out_right_moto (void)
{
if (Right_moto_stop)
{
if (pwm_val_right <= push_val_right)
{Right_moto_pwm = 1;
Right_moto2_pwm = 1; }
else
{Right_moto_pwm = 0;
Right_moto2_pwm = 0;}
if (pwm_val_right> = 10)
pwm_val_right = 0;
}
más {Right_moto_pwm = 0; Right_moto2_pwm = 0; }
}
/ *********************************************** *** /
///La subfunción de servicio de interrupción TIMER0 genera señal PWM /
temporizador nulo0 () interrupción 1 usando 2
{
TH0 = 0XF8; // 1Ms timing
TL0 = 0X30 ;
time ++;
pwm_val_left ++;
pwm_val_right ++;
pwm_out_left_moto ();
pwm_out_right_moto ();
} ;
// coche adelante
vacío adelante ()
{
ET0 = 1;
run (); // programa pwm
left_motor_go; // motor izquierdo adelante
right_motor_go; // motor derecho adelante
left_motor2_go; // motor izquierdo adelante rueda trasera derecha
right_motor2_go; // motor derecho trasera hacia adelante
}
void left_go () // Gire a la izquierda
{
ET0 = 1;
run ();
left_motor_back;
right_motor_go;
left_motor2_back;
right_motor2_go;
delay (700);
forward ();
}
// gire a la derecha
void right_go ()
{
ET0 = 1;
run ( );
delay (50);
right_motor_back;
left_motor_go;
right_motor2_back;
left_motor2_go;
delay (700);
forward ();
}
// auto left turn circle
void left ()
{
ET0 = 1;
run ();
delay (50);
right_motor_go ; // motor derecho adelante
left_motor_back; // motor izquierdo atrás
right_motor2_go; // motor derecho adelante
left_motor2_back; // motor izquierdo atrás
}
// Coche gire a la derecha
vacío ()
{
ET0 = 1;
run ();
left_motor_go;
right_motor_back;
left_motor2_go;
right_motor2_back;
}
// 小车 后退
void back ()
{
ET0 = 1;
correr();
left_motor_back;
right_motor_back;
left_motor2_back;
right_motor2_back;
}
// car stop
void stop ()
{
ET0 = 0;
P1 = 0;
P0 = 0;
}
// Interrupción del puerto serie
nulo UART_SER () interrupción 4
{
if (RI)
{
RI = 0; // Borrar el
conmutador del indicador de recepción (SBUF)
{
case 'g': forward (); break; // forward
case 'b': back (); break; //
mayúsculas y minúsculas 'l': left (); break; //
mayúsculas y minúsculas 'r': right (); break; //
mayúsculas y minúsculas 's': stop (); break ; // Stop
case 'z': left_go (); break; //
Caso de conducción de giro a la izquierda 'y': right_go (); break; //
Caso de conducción de giro a la derecha 'p': pwm ++; break; // Acelerar
caso ' c ': pwm–; break; // Reducir la velocidad
}
}
}
void main ()
{
TMOD =
0X01 ; TH0 = 0XF8; // temporización de 1
ms TL0 = 0X30;
TR0 = 1;
ET0 = 1;
EA = 1;
UART_INIT (); // Inicialización de puerto serie
mientras que (1);
}
Finalmente, si tiene algún comentario o sugerencia, puede dejarme un mensaje, déjenos aprender juntos y progresar juntos.Si
necesita el código completo o el archivo de diseño, déjeme un mensaje o mensaje privado a continuación, y responderá tan pronto como lo vea.
Gracias
