Anuncio TOP B1 Mensaje

Colapsar

Anuncio TOP B4 Mensaje (Mobile)

Colapsar

Anuncio

Colapsar
No hay anuncio todavía.

Control 2 motores DC según espacio recorrido.

Colapsar
X
 
  • Filtrar
  • Tiempo
  • Mostrar
Limpiar Todo
nuevos mensajes

  • Control 2 motores DC según espacio recorrido.

    Hola muy buenas,

    os voy a comentar mi idea espero que de la mejor manera posible:

    tengo un proyecto en mente que consta de un "coche" que se moverá a través de 2 motores DC junto con un L298N.
    La idea es (adjunto foto) que mi coche vaya en linea recta X distancia, gire 90º, recorra de nuevo X distancia y una vez allí se de la vuelta y llegue por el mismo camino al punto de partida.

    Pienso que calculando la velocidad del "coche" mediante las ruedas que lleva podría establecer el tiempo que tarda en recorrer ese espacio y así poder programarlo...

    Como veis, al menos a mi, me parece que la idea no es dificil pero ponerla en practica mediante la programacion oportuna (dado que no ando muy avanzado en ese tema) puede ser un quebradero de cabeza.

    ¿Como lo veis? ¿alguna idea?

    Muchas gracias
    Archivos Adjuntos

  • #2
    Hola
    El driver que comentas también es válido para motores paso a paso, que puedes controlar mejor la relación de vueltas, dependiendo de la multiplicación y tamaño de rueda, podrías establecer una relación distancia/vuelta/paso.
    Con motores DC la cosa se complica, deberías meter al menos un encoder para contabilizar el número de vueltas.

    https://electronilab.co/tutoriales/t...o-con-arduino/

    un saludo

    Comentario


    • #3
      Sí totalmente, tengo un L289N para manejar los dos motores DC.
      Mi problemática viene a la hora de programar, no se bien como hacerlo...
      Le seguiré dando vueltas al coco, toda ayuda es bien recibida.
      Un saludo

      Comentario


      • #4
        Mi problemática viene a la hora de programar, no se bien como hacerlo...
        Yo crearía las siguientes funciones.

        -Función número de vueltas de un motor paso a paso dependiendo del parámetro distancia ( puedes implementar la marcha atrás también)
        -Función giro horario
        -Función giro antihorario
        -Función giro 180 grados, o llamas dos veces a una Función de giro.

        Y en el loop del arduino hazte la lógica del trazado.
        Algo del estilo, está sin verificar , que lo escribí mientras tomaba el café de la mañana jejeje
        Pero igual te ayuda de guía. Usé el código del link que te envié en el mensaje anterior

        #include <Stepper.h>

        const int stepsPerRevolution = 48; // cambie este valor por el numero de pasos de su motor
        const float DistancePerRevolution = 0.1; // cambie este valor por la distancia recorrida en una revolución

        // inicializa la libreria 'stepper' en los pines 8 a 11
        Stepper myStepper1(stepsPerRevolution, 8,9,10,11);
        Stepper myStepper2(stepsPerRevolution, 4,5,6,7);

        void setup() {
        // establece la velocidad en 60rpm
        myStepper1.setSpeed(60);
        myStepper2.setSpeed(60);
        // inicializa el puerto serial
        Serial.begin(9600);
        }

        FuncDistancaDelante(float Distancia)
        { float NumeroRevoluciones

        NumeroRevoluciones=Distancia/DistancePerRevolution;
        myStepper1.step(stepsPerRevolution*NumeroRevolucio nes);
        myStepper2.step(stepsPerRevolution*NumeroRevolucio nes);
        }
        FuncDistancaAtras(float Distancia)
        { float NumeroRevoluciones

        NumeroRevoluciones=Distancia/DistancePerRevolution;
        myStepper1.step(-stepsPerRevolution*NumeroRevoluciones);
        myStepper2.step(stepsPerRevolution*NumeroRevolucio nes);
        }

        FuncGira90()
        {
        myStepper1.step(-stepsPerRevolution);
        myStepper2.step(stepsPerRevolution);
        }

        FuncGira180()
        {
        myStepper1.step(2*(-stepsPerRevolution));
        myStepper2.step(2*(stepsPerRevolution));
        }

        void loop() {
        // Trazado

        }
        Editado por última vez por RubenBA; https://www.infoplc.net/foro/member/63237-rubenba en 05 jul 17, 13:33:32.

        Comentario


        • #5
          Muchas gracias, me pondré a ello en cuanto pueda.
          De momento estoy intentando entender ciertas funciones para controlar los motores DC, y me he encontrado con esta programación.
          La cual es básica ya que hace que los motores vayan hacia delante, hacia atrás y se paren.

          const int pinENA = 5;
          const int pinIN1 = 2;
          const int pinIN2 = 3;
          const int pinIN3 = 7;
          const int pinIN4 = 4;
          const int pinENB = 6;

          const int waitTime = 4000; //espera entre fases

          const int speed = 200; //velocidad de giro 80% (200/255)

          const int pinMotorA[3] = {pinENA, pinIN1, pinIN2 };
          const int pinMotorB[3] = {pinENB, pinIN3, pinIN4 };



          void setup()
          {
          pinMode(pinIN1, OUTPUT);
          pinMode(pinIN2, OUTPUT);
          pinMode(pinENA, OUTPUT);
          pinMode(pinIN3, OUTPUT);
          pinMode(pinIN4, OUTPUT);
          pinMode(pinENB, OUTPUT);
          }

          void loop()
          {
          moveForward(pinMotorA, 180);
          moveForward(pinMotorB, 180);
          delay(waitTime);

          moveBackward(pinMotorA, 180);
          moveBackward(pinMotorB, 180);
          delay(waitTime);

          fullStop(pinMotorA);
          fullStop(pinMotorB);
          delay(waitTime);
          }

          void moveForward(const int pinMotor[3], int speed) // Seguir adelante

          {
          digitalWrite(pinMotor[1], HIGH);
          digitalWrite(pinMotor[2], LOW);

          analogWrite(pinMotor[0], speed);
          }

          void moveBackward(const int pinMotor[3], int speed) // hacia atrás

          {
          digitalWrite(pinMotor[1], LOW);
          digitalWrite(pinMotor[2], HIGH);

          analogWrite(pinMotor[0], speed);
          }

          void fullStop(const int pinMotor[3]) // todo parado
          {
          digitalWrite(pinMotor[1], LOW);
          digitalWrite(pinMotor[2], LOW);

          analogWrite(pinMotor[0], 0);
          }
          Y lo que no entiendo es el porque pone en los distintos void pinMotor[1] ó pinMotor[2], si de esta forma no ha llamado a nada.
          ¿Alguien puede aclararme esta programación?

          Gracias

          Comentario


          • #6
            Hola Gorkapro, no he tocado ni usado arduinos y acabo de leer un poco un manual...pero más o menos te voy a explicar un poco lo que ha echo el que ha programado eso:

            Primero a declarado unas variables que corresponden a los pines que va a usar para sacar las señales digitales/analógicas.
            *************************
            const int pinENA = 5;
            const int pinIN1 = 2;
            const int pinIN2 = 3;
            const int pinIN3 = 7;
            const int pinIN4 = 4;
            const int pinENB = 6;
            *************************

            Segundo a declarado en otras variables un tiempo de espera y una velocidad.
            *************************
            const int waitTime = 4000; //espera entre fases
            const int speed = 200; //velocidad de giro 80% (200/255)
            *************************

            Tercero a declarado unos Array (pinMotorA y pinMotorB) y dentro a asigando a las posiciones del array los pines de salida que declaro al principio.
            *************************
            const int pinMotorA[3] = {pinENA, pinIN1, pinIN2 };
            const int pinMotorB[3] = {pinENB, pinIN3, pinIN4 };
            *************************

            Cuarto declara que toodas las variables de los pines son Salidas.
            *************************
            void setup()
            {
            pinMode(pinIN1, OUTPUT);
            pinMode(pinIN2, OUTPUT);
            pinMode(pinENA, OUTPUT);
            pinMode(pinIN3, OUTPUT);
            pinMode(pinIN4, OUTPUT);
            pinMode(pinENB, OUTPUT);
            }
            *************************

            Quinto en el programa llama a las distintos procedimientos que ha creado en la parte de abajo y les pasa las variables con las que tienen que trabajar.
            *************************
            void loop()
            {
            moveForward(pinMotorA, 180);
            moveForward(pinMotorB, 180);
            delay(waitTime);
            moveBackward(pinMotorA, 180);
            moveBackward(pinMotorB, 180);
            delay(waitTime);
            fullStop(pinMotorA);
            fullStop(pinMotorB);
            delay(waitTime);
            }
            *************************

            ....los procedimientos si te fijas tienen unas constantes declaradas entre parentesis, dichas constantes son variables de entrada que se le meten al procedimiento para que pueda trabajar con esas variables dentro. Vamos, que declaras fuera una variables y la puedes usar dentro. En el caso por ejemplo del moveForward:

            *************************
            void loop()
            {
            moveForward(pinMotorA, 180); ***Esto esta llamando al procedimiento y le está pasando las variables creadas en el tercer paso en el cual creo un Array (const int pinMotorA[3] = {pinENA, pinIN1, pinIN2 } esta persona le pasa todo el array y luego un valor de 180, para usarlo dentro del procedimiento.
            *************************
            ***Este es el procedimiento:
            void moveForward(const int pinMotor[3], int speed) ***Crea el procemiento con unas variables que son iguales a las que le pasa en la llamada un Array y un valor entero. En el array pinMotor[3] estará trabajando con el array de fuera pinMotora y la variable speed tendrá el valor 180 que le ha metido desde fuera también
            *************************
            {
            digitalWrite(pinMotor[1], HIGH); ***Aquí le está metiendo al array de este procedimiento pinMotor y en la posición del array [1] (o sea la segunda posición porque los array empiezan en 0,1,2,3,4....etc...) que corresponderá a la posición del array de fuera pinMotorA[1] o sea pinIN1 o sea al pin=2 un valor HIGH que es de 5V o 3.3V según la placa.

            digitalWrite(pinMotor[2], LOW);***Aquí le está metiendo al array de este procedimiento pinMotor y en la posición del array [2] (o sea la tercera posición) que corresponderá a la posición del array de fuera pinMotorA[2] o sea pinIN2 o sea al pin=3 un valor LOW que es de 0V.

            analogWrite(pinMotor[0], speed);***Aquí le está metiendo al array de este procedimiento pinMotor y en la posición del array [0] (o sea la primera posición) que corresponderá a la posición del array de fuera pinMotorA[0] o sea pinENA o sea al pin=5 un valor entero de 180.
            }
            *************************


            ...bueno, creo que más o menos se entiende. Espero haberte ayudado y si algún otro compañero cree que algo está mal, por favor corregidme, porque como os digo yo de Arduino no he tocado nada. Un saludo y espero haberte sido de ayuda.
            Editado por última vez por Brosnin; https://www.infoplc.net/foro/member/63290-brosnin en 12 jul 17, 01:05:53.

            Comentario


            • #7
              Muchisimas gracias, de gran ayuda.
              Tengo unas cuantas dudas más, voy a intentar resolverlas antes de volver a preguntar.
              ¡Muchas gracias compañero!

              Comentario


              • #8
                Yo te recomiendo el video de construcción de un carro autónomo de tutos ingeniería



                https://www.youtube.com/watch?v=OInrjq7FTy8

                Comentario

                Anuncio Footer B3 Mensaje

                Colapsar

                Anuncio Footer B5 Mensaje (Mobile) 300x600

                Colapsar
                Trabajando...
                X