Variador de Frecuencia PWM para Motor DC (5000 RPM) en Tinkercad

 https://www.youtube.com/watch?v=7IyGmp4OHcs

Variador de Frecuencia PWM para Motor DC (5000 RPM) en Tinkercad

En este tutorial aprenderás a controlar la velocidad de un motor DC usando PWM (Modulación por Ancho de Pulso) en Arduino para alcanzar aproximadamente 5000 RPM.

Componentes Necesarios

  • Arduino Uno

  • Motor DC

  • Transistor MOSFET (IRF520N)

  • Diodo de protección (1N4007)

  • Resistencia 220Ω

  • Fuente de alimentación externa (9-12V)

  • Protoboard

  • Cables de conexión

Circuito en Tinkercad

Diagrama de Conexiones:

text
Arduino Uno:
- Pin 9 (PWM) → Resistencia 220Ω → Gate MOSFET
- GND → Source MOSFET

MOSFET (IRF520N):
- Gate → Resistencia desde Arduino
- Drain → Terminal negativo del motor
- Source → GND

Motor DC:
- Terminal positivo → Fuente externa (+)
- Terminal negativo → Drain MOSFET

Diodo (1N4007):
- Cátodo (+) → Terminal positivo del motor
- Ánodo (-) → Terminal negativo del motor

Fuente Externa:
- Positivo → Motor positivo
- Negativo → GND Arduino

Código Arduino

cpp
// Variador de Frecuencia PWM para Motor DC
// Objetivo: Controlar velocidad hasta 5000 RPM

const int motorPin = 9;  // Pin PWM para controlar el motor
int velocidad = 0;       // Variable para almacenar la velocidad (0-255)

void setup() {
  pinMode(motorPin, OUTPUT);
  Serial.begin(9600);
  Serial.println("Variador de Frecuencia PWM - Control Motor DC");
  Serial.println("Velocidad objetivo: ~5000 RPM");
  Serial.println("Comandos: + (aumentar), - (disminuir), 0 (apagar)");
}

void loop() {
  // Verificar si hay datos disponibles en el monitor serial
  if (Serial.available() > 0) {
    char comando = Serial.read();
    
    switch(comando) {
      case '+':  // Aumentar velocidad
        if (velocidad < 255) {
          velocidad += 25;
          if (velocidad > 255) velocidad = 255;
        }
        break;
        
      case '-':  // Disminuir velocidad
        if (velocidad > 0) {
          velocidad -= 25;
          if (velocidad < 0) velocidad = 0;
        }
        break;
        
      case '0':  // Apagar motor
        velocidad = 0;
        break;
    }
    
    // Aplicar la velocidad al motor
    analogWrite(motorPin, velocidad);
    
    // Mostrar información
    Serial.print("Velocidad PWM: ");
    Serial.print(velocidad);
    Serial.print("/255 (");
    Serial.print((velocidad * 100) / 255);
    Serial.println("%)");
    
    // Estimación de RPM (varía según el motor)
    int rpmEstimado = map(velocidad, 0, 255, 0, 5000);
    Serial.print("RPM estimado: ");
    Serial.println(rpmEstimado);
    Serial.println();
  }
}

// Función adicional para control preciso
void setVelocidadRPM(int rpmDeseado) {
  // Conversión de RPM a valor PWM (ajustar según motor específico)
  int pwmValue = map(rpmDeseado, 0, 5000, 0, 255);
  
  if (pwmValue > 255) pwmValue = 255;
  if (pwmValue < 0) pwmValue = 0;
  
  analogWrite(motorPin, pwmValue);
  velocidad = pwmValue;
  
  Serial.print("Objetivo: ");
  Serial.print(rpmDeseado);
  Serial.print(" RPM - PWM: ");
  Serial.println(pwmValue);
}

Pasos para Implementar en Tinkercad

Paso 1: Montar el Circuito

  1. Abre Tinkercad y crea un nuevo circuito

  2. Agrega los componentes de la lista

  3. Conecta según el diagrama proporcionado

Paso 2: Programar

  1. Copia el código en el editor de Arduino

  2. Ajusta los parámetros si es necesario

  3. Verifica que no haya errores

Paso 3: Probar

  1. Inicia la simulación

  2. Abre el monitor serial

  3. Usa los comandos:

    • + para aumentar velocidad

    • - para disminuir velocidad

    • 0 para apagar

Código Alternativo con Control por Potenciómetro

cpp
const int motorPin = 9;
const int potPin = A0;

void setup() {
  pinMode(motorPin, OUTPUT);
  Serial.begin(9600);
}

void loop() {
  int potValue = analogRead(potPin);
  int velocidad = map(potValue, 0, 1023, 0, 255);
  
  analogWrite(motorPin, velocidad);
  
  // Mostrar valores cada 500ms
  static unsigned long lastTime = 0;
  if (millis() - lastTime > 500) {
    lastTime = millis();
    
    Serial.print("Potenciómetro: ");
    Serial.print(potValue);
    Serial.print(" - PWM: ");
    Serial.print(velocidad);
    Serial.print(" - RPM estimado: ");
    Serial.println(map(velocidad, 0, 255, 0, 5000));
  }
}

Consideraciones Importantes

  1. Protección con Diodo: Siempre usa un diodo en paralelo inverso con el motor para proteger el circuito de picos de voltaje.

  2. Fuente de Alimentación: Para motores que requieren más corriente de la que Arduino puede proveer, usa una fuente externa.

  3. MOSFET: El IRF520N puede manejar hasta 24V y 9A, suficiente para la mayoría de motores DC pequeños.

  4. RPM Real vs Estimado: Los 5000 RPM son una estimación. El RPM real depende del motor específico y la carga.

Solución de Problemas

  • Motor no gira: Verifica conexiones y polaridad

  • Velocidad inconsistente: Revisa la fuente de alimentación

  • MOSFET se calienta: Puede necesitar disipador de calor

  • RPM menores a 5000: Ajusta el mapeo en el código según tu motor

 Variador de Frecuencia para Motor DC (5000 RPM) - Arduino

Instituto Tecnológico Costa Rica
Escuela de Mantenimiento Industrial
Presentado por: [Tu Nombre] y Antonio

Introducción

Hoy vamos a exponer acerca del variador de frecuencia programado en Arduino para controlar un motor a 5000 revoluciones por minuto. A continuación mostramos los pasos para armar el circuito completo.

Materiales Utilizados

  • Arduino Uno

  • Motor DC

  • Transistor MOSFET

  • Diodo de protección

  • Resistencias 220Ω

  • Potenciómetro

  • 4 Switches (conmutadores)

  • Osciloscopio virtual

  • Voltímetro

  • Protoboard

  • Cables de conexión

Procedimiento de Conexión

Paso 1: Conexión del Potenciómetro

Comenzamos conectando las terminales del potenciómetro para controlar manualmente la velocidad del motor.

Paso 2: Alimentación del Conmutador

Conectamos los cables para alimentar lo que es el conmutador y las resistencias. Estas resistencias ya estaban pre-conectadas para facilitar la instalación.

Paso 3: Conexión del Osciloscopio

Procedemos a conectar el osciloscopio en las terminales 3 y luego a tierra, para visualizar la señal PWM.

Paso 4: Alimentación del Arduino

Conectamos la tierra del Arduino con la tierra de la protoboard para establecer una referencia común.

Paso 5: Conexión del Transistor

Conectamos la resistencia a la terminal 3 para que alimente el transistor MOSFET. Del transistor vamos a conectar una línea al negativo del motor.

Paso 6: Cierre del Circuito

Cerramos el circuito conectando el positivo del motor a la fuente de alimentación.

Paso 7: Conexión del Voltímetro

Conectamos un voltímetro a ambas terminales del motor para monitorear el voltaje aplicado.

Análisis del Circuito

Al tener ya lista nuestra conexión, procedemos a analizar las funciones de cada elemento:

  • Potenciómetro: Control manual continuo de velocidad

  • Switches: Control por pasos (25%, 50%, 75%, 100%)

  • MOSFET: Actúa como interruptor de potencia

  • Diodo: Protección contra picos de voltaje inverso

  • Resistencias: Limitación de corriente

Programación Arduino

Explicación del Código

Declaración de Variables:

cpp
int puerto_salida = 3;     // Salida PWM principal
int puerto11 = 11;         // Switch 1
int puerto10 = 10;         // Switch 2  
int puerto9 = 9;           // Switch 3
int puerto6 = 6;           // Switch 4
int potenciometro = A0;    // Entrada analógica

Configuración Inicial (Setup):

cpp
void setup() {
  pinMode(puerto_salida, OUTPUT);
  pinMode(puerto11, INPUT);
  pinMode(puerto10, INPUT);
  pinMode(puerto9, INPUT);
  pinMode(puerto6, INPUT);
  pinMode(potenciometro, INPUT);
  analogWrite(puerto_salida, 0);
  Serial.begin(115200);
}

Lógica Principal (Loop):

Control por Potenciómetro

Cuando todos los switches están apagados:

cpp
if (C1 == LOW && C2 == LOW && C3 == LOW && C4 == LOW){
  E_pot = map(valor_potenciometro, 0, 1023, 0, 73);
  analogWrite(puerto_salida, E_pot);
  int rpm = map(E_pot, 0, 73, 0, 5000);
}

Control por Switches (Pasos Predefinidos)

Switch 1 - 25% (1250 RPM):

cpp
if (C1 == HIGH) { 
  int t = 18; // 25% de 73 = 18.25
  analogWrite(puerto_salida, t);
}

Switch 2 - 50% (2500 RPM):

cpp
if (C2 == HIGH) {
  int t = 37; // 50% de 73 = 36.5
  analogWrite(puerto_salida, t);
}

Switch 3 - 75% (3750 RPM):

cpp
if (C3 == HIGH) {
  int t = 55; // 75% de 73 = 54.75
  analogWrite(puerto_salida, t);
}

Switch 4 - 100% (5000 RPM):

cpp
if (C4 == HIGH) {
  int t = 73; // 100% - valor calculado
  analogWrite(puerto_salida, t);
}

Cálculo para 5000 RPM

El valor 73 se calculó mediante regla de tres:

  • 255 (PWM máximo) → 17,485 RPM

  • X (PWM necesario) → 5,000 RPM

  • X = (5,000 × 255) / 17,485 ≈ 72.91 ≈ 73

Demostración Práctica

Señal en Osciloscopio

En el osciloscopio observamos una señal cuadrada PWM cuya frecuencia y ciclo de trabajo varían según la velocidad seleccionada.

Monitor Serial

El monitor serial nos muestra en tiempo real las revoluciones del motor:

text
Revoluciones: 0
Revoluciones: 1250
Revoluciones: 2500  
Revoluciones: 3750
Revoluciones: 5000

Comportamiento del Motor

  • Con switches: Velocidades predefinidas precisas

  • Con potenciómetro: Control continuo desde 0 hasta 5000 RPM

  • Estabilidad: El motor mantiene constante la velocidad seleccionada

Ventajas del Sistema

  1. Control Dual: Potenciómetro y switches para diferentes tipos de control

  2. Precisión: Valores calculados matemáticamente

  3. Seguridad: Protección con diodo y resistencias limitadoras

  4. Monitoreo: Visualización en tiempo real de RPM

  5. Flexibilidad: Fácil modificación de valores de velocidad

Conclusiones

Hemos demostrado exitosamente el funcionamiento de un variador de frecuencia para motor DC controlado por Arduino, capaz de alcanzar 5000 RPM con precisión. El sistema ofrece múltiples métodos de control y protección eléctrica, siendo una solución eficiente para aplicaciones de mantenimiento industrial.

Comentarios

Publicar un comentario

Entradas más populares de este blog

12. Demostracion de como usar Tinkercad para simular Arduino con circuitos

  Simulación de Circuitos con Arduino en Tinkercad ¿Por qué simular circuitos? En el aprendizaje de electrónica y programación con Arduino, lo ideal es trabajar con componentes físicos. Sin embargo, si no tienes acceso a los componentes (Arduino, LEDs, resistencias, etc.), no significa que no puedas aprender y practicar. La simulación es una herramienta poderosa que te permite diseñar, probar y depurar tus circuitos y código de forma virtual. En este tutorial, aprenderás a usar  Tinkercad Circuits , una plataforma en la nube gratuita, para simular el clásico proyecto de parpadeo de dos LEDs. Paso 1: Acceder a Tinkercad Abre tu navegador web y ve a la página de  Tinkercad . Haz clic en  Iniciar sesión  (Sign in). Selecciona la opción  Iniciar sesión con Google  (o crea una cuenta si es necesario). Elige la cuenta de Gmail con la que deseas registrarte e inicia sesión. Paso 2: Crear un Nuevo Circuito En la página principal de Tinkercad, haz clic en la pe...
Leer más

11. Ejemplos Básicos de Leds y Pulsadores

  Programación Básica con Arduino - Control de LEDs y Pulsador 📋 Descripción General Este tutorial te guiará a través de 3 ejemplos prácticos de programación con Arduino, desde el parpadeo básico de un LED hasta el control con un pulsador. Duración:  15:28 minutos 🧩 Ejemplo 1: LED Parpadeante en PIN 8 📌 Objetivo Conectar un LED al PIN 8 y hacerlo parpadear infinitamente con intervalos de 500ms encendido y 500ms apagado. 🔌 Esquemático LED: Ánodo (+) conectado al PIN 8 a través de una resistencia Cátodo (-) conectado a GND (tierra) 💻 Código arduino void setup ( ) { pinMode ( 8 , OUTPUT ) ; // Configurar PIN 8 como salida } void loop ( ) { digitalWrite ( 8 , HIGH ) ; // Encender LED delay ( 500 ) ; // Esperar 500ms digitalWrite ( 8 , LOW ) ; // Apagar LED delay ( 500 ) ; // Esperar 500ms } ⚙️ Configuración En Herramientas → Placa: seleccionar "Arduino Uno" En Herramientas → Puerto: seleccionar el puerto correcto Car...
Leer más

Lectura de Potenciómetro con Arduino Uno en Tinkercad

  Introducción En este tutorial aprenderás a conectar y leer un potenciómetro con una tarjeta Arduino Uno usando Tinkercad. Un potenciómetro es una resistencia variable que nos permite controlar manualmente valores analógicos. Componentes Necesarios 1 x Arduino Uno 1 x Potenciómetro 3 x Cables jumper 1 x Protoboard Paso a Paso Paso 1: Configuración del Circuito Conectar el potenciómetro a la protoboard: Coloca el potenciómetro en la protoboard Tiene 3 pines: dos extremos y un pin central Conexiones del potenciómetro: Pin izquierdo  → Conectar a  5V  de Arduino Pin derecho  → Conectar a  GND  de Arduino Pin central  → Conectar a  A0  (entrada analógica) Paso 2: Diagrama de Conexiones text POTENCIÓMETRO ARDUINO UNO Pin 1 → 5V Pin 2 → A0 Pin 3 → GND Paso 3: Programación en Arduino cpp // Definir el pin del potenciómetro const int potPin = A0 ; // Variable para almacenar el valor leído int potValue...
Leer más