[ad_1]
Un motor de CC suele funcionar con corriente continua. Convierte la energía eléctrica en energía mecánica. Este movimiento de rotación es la fuente de energía necesaria para muchas aplicaciones industriales. El control de crucero es la función crucial para el funcionamiento del motor. Con el control de velocidad del motor, podemos cambiar la velocidad del motor según las necesidades de la aplicación. Se utiliza en muchas aplicaciones en tiempo real, como el control de vehículos robóticos, fábricas de papel y ascensores.
motor de corriente continua
Un motor de CC es un dispositivo giratorio que convierte la energía eléctrica en forma de corriente continua en energía mecánica en forma de rotación del eje del motor. La velocidad del motor de CC se puede controlar variando el voltaje de CC. La tecnología PWM es útil para aplicar un voltaje cambiante.
Construyendo y trabajando
Este circuito está construido sobre una placa de pruebas. Este diseño se basa en la tecnología Arduino Nano. Incluye Arduino Nano, controlador de motor L298, potenciómetro 10K, 1 display de siete segmentos, motor BO 100rpm, engranaje, eje, portapilas, batería 18650 Li-on cell 3.7V 2000mAh (2 celdas). El potenciómetro tiene 3 pines: uno está conectado a GND, otro está conectado a 5 V y el pin del medio está conectado a A1 (pin analógico). Siete pines de segmento a a g están conectados desde el pin 13 al pin 7 y el pin decimal está conectado al 6. Se trata de una pantalla de cátodo común de 7 segmentos con dos pines comunes conectados a GND. El pin 5 del Arduino Nano está conectado al pin de habilitación A del controlador del motor L298. Los pines 3 y 4 están conectados a IN1 e IN2 del controlador del motor L298. Conecte los motores BO a los pasadores del motor impulsor del motor L298 e inserte las ruedas en las cajas de cambios. Los motores se pueden controlar mediante un potenciómetro y la velocidad se muestra en una pantalla de siete segmentos en rpm.
arduino nano
El Arduino Nano es una placa compatible con placa de pruebas completa y de tamaño micro basada en ATmega328. El Arduino Nano se puede alimentar a través del puerto USB Mini-B. La fuente de voltaje más alto se selecciona automáticamente como fuente de energía. El ATmega328 es de 32 KB. Cada uno de los 14 pines digitales del Nano se puede utilizar como entrada o salida con las funciones pinMode(), digitalWrite() y digitalRead(). Funcionan con 5 voltios. Cada pin puede proporcionar o recibir un máximo de 40 mA y tiene una resistencia pull-up interna.
Controlador L298:
Este módulo controlador de motor basado en L298N – 2A es un controlador de motor de alto rendimiento perfecto para accionar motores de CC y motores paso a paso. Utiliza el popular IC de controlador de motor L298 y tiene un regulador integrado de 5 V que puede suministrar a un circuito externo. Puede controlar hasta 4 motores DC o 2 motores DC con control de dirección y velocidad. Este módulo controlador de motor L298N – 2A es perfecto para proyectos de robótica y mecatrónica, perfecto para controlar motores de microcontroladores, interruptores, relés, etc. Perfecto para accionar motores CC y paso a paso para micro ratones, robots de seguimiento de líneas, brazos de robots, etc.
Potenciómetro 10K
Los potenciómetros son útiles para controlar los diversos parámetros eléctricos de un circuito. Este es un potenciómetro de una sola vuelta de 10k con función de perilla giratoria. Este potenciómetro le permite cambiar la resistencia entre 0 y 10 kOhm simplemente girando la perilla. El eje tiene 15 mm de largo y una resistencia total de 10 kOhm.
Pantalla de siete segmentos
Hoy en día, las pantallas de siete segmentos se utilizan ampliamente en sistemas de visualización para diversas aplicaciones. Las pantallas de siete segmentos constan de LED. Se utilizan para mostrar números como el nivel de gasolina en los vehículos, la hora en los relojes digitales, la velocidad de los vehículos, la velocidad de las lavadoras, los aires acondicionados y varios tipos de paneles de control. La pantalla de siete segmentos contiene 7 LED para mostrar números. Puede mostrar números del 0 al 9 en un solo segmento de siete.
Display de siete segmentos con cátodo común
- Para el cátodo común, conecte los pines comunes de 7 segmentos al pin GND de Arduino Nano.
- Conecte el pin de +5 voltios del Arduino Nano al pin del punto decimal en serie con una resistencia de 470 ohmios para limitar la corriente. Brillará.
- En el cátodo común, los pines a,b,c,d,e,f,g y h de la pantalla de segmento están conectados a los nano pines de Arduino, que se pueden controlar mediante programación asignando valores.
lista de partes
Arduino Nano, controlador L298, motor BO de 100 RPM, pantalla de cátodo común de siete segmentos, potenciómetro de 10 K, neumáticos, placa de pruebas, cables de puente, cable USB, caja, soporte de batería, módulo de batería 18650 3,7 V 2000 mAh (2 celdas)
software
El proyecto está programado utilizando una herramienta Arduino 1.8.19. El módulo potenciómetro de 10k está conectado a un pin A1 analógico de Arduino Nano, 1 pin está conectado a 5 V de Arduino Nano, 1 pin está conectado a GND de Arduino Nano. El pin 5 del Arduino Nano está conectado al pin de habilitación A del controlador del motor L298. Los pines 3 y 4 están conectados a IN1 e IN2 del controlador del motor L298. Conecte el motor BO de 100 RPM a las clavijas del motor del controlador del motor L298 e inserte la rueda en la caja de cambios. A través del software, el potenciómetro envía una señal analógica al pin A1 y en consecuencia Arduino Nano envía comandos al controlador del motor L298, que a su vez envía comandos al motor para que funcione de acuerdo con el valor del potenciómetro.
Pruebas
Realice las conexiones según el diagrama del circuito. Tensión de alimentación al soporte de la batería 18650 Li-on Cell 3,7V 2000mAh (2 celdas – 7,4V). Verifique el estado del display de siete segmentos si muestra cero. Mueva la perilla del potenciómetro de 10K y registre la velocidad mostrada en RPM de 0 a 9 RPM. Aquí 0 significa 0 rpm y 9 significa 90 rpm y un solo punto en la pantalla de siete segmentos significa velocidad máxima 100 rpm. Observe la velocidad del motor BO DC de acuerdo con la rotación de la perilla (0-255). El valor 0 del potenciómetro significa 0 rpm (revoluciones por minuto – velocidad mínima), el valor 255 se refiere a 100 rpm (velocidad máxima). Este prototipo se puede ampliar a 2 o más motores con una pantalla adicional de siete segmentos o una pantalla LCD con control de dirección del motor de CC para diversas aplicaciones industriales y de robótica.
int seg_Pins[] = {13, 12, 11, 10, 9, 8, 7, 6}; // { a b c d e f g . )
int pot_map;
int pot_input;
////MOTOR1 PINS
int ena = 5;
int in1 = 3;
int in2 = 4;
byte seg_Code[11][8] = {
// a b c d e f g .
{ 1, 1, 1, 1, 1, 1, 0, 1}, // 0
{ 0, 1, 1, 0, 0, 0, 0, 0}, // 1
{ 1, 1, 0, 1, 1, 0, 1, 0}, // 2
{ 1, 1, 1, 1, 0, 0, 1, 0}, // 3
{ 0, 1, 1, 0, 0, 1, 1, 0}, // 4
{ 1, 0, 1, 1, 0, 1, 1, 0}, // 5
{ 1, 0, 1, 1, 1, 1, 1, 0}, // 6
{ 1, 1, 1, 0, 0, 0, 0, 0}, // 7
{ 1, 1, 1, 1, 1, 1, 1, 0}, // 8
{ 1, 1, 1, 1, 0, 1, 1, 0}, // 9
{ 0, 0, 0, 0, 0, 0, 0, 1} // .
};
void setup()
{
pinMode(A1, INPUT);
pinMode(ena, OUTPUT);
pinMode(in1, OUTPUT);
pinMode(in2, OUTPUT);
for (int i = 0; i < 8; i++)
{
pinMode(seg_Pins[i], OUTPUT);
}
Serial.begin(9600);
}
void loop()
{
pot_input = analogRead(A1);
pot_map= map(pot_input, 0, 1023, 0 , 255);
//Serial.println(pot_input);
Serial.println(pot_map);
delay(300);
if ((pot_map > 1) && (pot_map <= 25))
{
digitalWrite(in1,LOW);
digitalWrite(in2,HIGH);
analogWrite(ena, pot_map);
for (int n = 1; n < 2; n++)
{
display_Digit(n);
delay(2000); ///2 second delay
}
}
else if ((pot_map > 25) && (pot_map <= 50))
{
digitalWrite(in1,LOW);
digitalWrite(in2,HIGH);
analogWrite(ena, pot_map);
for (int n = 2; n < 3; n++)
{
display_Digit(n);
delay(2000); ///2 second delay
}
}
else if ((pot_map > 50) && (pot_map <= 75))
{
digitalWrite(in1,LOW);
digitalWrite(in2,HIGH);
analogWrite(ena, pot_map);
for (int n = 3; n < 4; n++)
{
display_Digit(n);
delay(2000); ///2 second delay
}
}
else if ((pot_map > 75) && (pot_map <= 100))
{
digitalWrite(in1,LOW);
digitalWrite(in2,HIGH);
analogWrite(ena, pot_map);
for (int n = 4; n < 5; n++)
{
display_Digit(n);
delay(2000); ///2 second delay
}
}
else if ((pot_map > 100) && (pot_map <= 125))
{
digitalWrite(in1,LOW);
digitalWrite(in2,HIGH);
analogWrite(ena, pot_map);
for (int n = 5; n < 6; n++)
{
display_Digit(n);
delay(2000); ///2 second delay
}
}
else if ((pot_map > 125) && (pot_map <= 150))
{
digitalWrite(in1,LOW);
digitalWrite(in2,HIGH);
analogWrite(ena, pot_map);
for (int n = 6; n < 7; n++)
{
display_Digit(n);
delay(2000); ///2 second delay
}
}
else if ((pot_map > 150) && (pot_map <= 175))
{
digitalWrite(in1,LOW);
digitalWrite(in2,HIGH);
analogWrite(ena, pot_map);
for (int n = 7; n < 8; n++)
{
display_Digit(n);
delay(2000); ///2 second delay
}
}
else if ((pot_map > 175) && (pot_map <= 200))
{
digitalWrite(in1,LOW);
digitalWrite(in2,HIGH);
analogWrite(ena, pot_map);
for (int n = 8; n < 9; n++)
{
display_Digit(n);
delay(2000); ///2 second delay
}
}
else if ((pot_map > 200) && (pot_map <= 225))
{
digitalWrite(in1,LOW);
digitalWrite(in2,HIGH);
analogWrite(ena, pot_map);
for (int n = 9; n < 10; n++)
{
display_Digit(n);
delay(2000); ///2 second delay
}
}
else if ((pot_map > 225) && (pot_map <= 255))
{
digitalWrite(in1,LOW);
digitalWrite(in2,HIGH);
analogWrite(ena, pot_map);
for (int n = 10; n < 11; n++)
{
display_Digit(n);
delay(2000); ///1 second delay
}
}
else
{
for (int n = 0; n < 1; n++)
{
display_Digit(n);
delay(2000); ///2 second delay
}
}
}
void display_Digit(int digit)
{
for (int i = 0; i < 8; i++)
{
digitalWrite(seg_Pins[i], seg_Code[digit][i]);
}
}
Diagrama de circuito :
[ad_2]