Consulta sobre motor y finales de carrera

International Español Software
1

Tengan buenos días tardes o noches No soy un experto experto en programación con arduino y le trago aquí una duda para que me ayuden

La cuestión es la siguiente tengo un ascensor de 4 pisos que lo he programado para que suba y baje una cierta cantidad de tiempo de acuerdo al piso que quiera ir en estos momentos el ascensor no tiene ningun tipo de sensor que le indique donde queda exactamente el piso El ascensor lo controlo con un teclado matricial 4x4

ahora bien quisiera que me ayudaran para que en lugar que suba o baje cierta cantidad de tiempo instalare finales de carrera. Así por ejemplo si quiero bajar al piso uno el motor baje y hasta que el final de carrera del piso uno se active se detenga el motor

2

este es mi código me imagino que habria que crear una variable para cada final de carrera y luego una sentencia if para que cuando el final de carrera se active apague el motor

//led
int led = 13;
//display
int num1 = A0;
int num2 = A1;
int num3 = A2;
int num4 = A3;
int num5 = A4;
int num6 = A5;
int num7 = A6;

int luz1 = 22;
int luz2 = 24;
int luz3 = 26;
int luz4 = 28;

#include<Keypad.h>

//motor
int IN1 = 3;
int IN2 = 2;
//teclado
const byte ROWS = 4;
const byte COLS = 4;
char keys[ROWS][COLS] = {
  {'1', '2', '3', 'A'},
  {'4', '5', '6', 'B'},
  {'7', '8', '9', 'C'},
  {'*', '0', '#', 'D'}
};
byte rowPins[ROWS] = {12, 11, 10, 9}; //Filas(pines del 9 al 6)
byte colPins[COLS] = {8, 7, 6, 5}; //Columnas (pines del 5 al)
Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );

/////////////////////////////////////////////////////////////////////////////VOID SETUP
void setup() {
  //motor
  pinMode (IN1, OUTPUT);    // Input4 conectada al pin
  pinMode (IN2, OUTPUT);    // Input3 conectada al pin

  pinMode (num1, OUTPUT);
  pinMode (num2, OUTPUT);
  pinMode (num3, OUTPUT);
  pinMode (num4, OUTPUT);
  pinMode (num5, OUTPUT);
  pinMode (num6, OUTPUT);
  pinMode (num7, OUTPUT);

  pinMode (luz1, OUTPUT);
  pinMode (luz2, OUTPUT);
  pinMode (luz3, OUTPUT);
  pinMode (luz4, OUTPUT);

  Serial.begin (9600);

}
////////////////////////////////////////////////////////////////////////////////VOID LOOP
void loop() {

  char key = keypad.getKey();
  if (key != 0)     // Si el valor es 0 es que no se ha pulsado ninguna tecla
    Serial.println(key);
  if (key) {
    switch (key)
    {
      case '2'://Cuando key A es oprimida.. de 4 a 1.
        Serial.println("2");// el monitor serial escribe ascensor
        // Motor gira en sentido inverso
        digitalWrite (IN1, HIGH);
        digitalWrite (IN2, LOW);
        numeroDos();
        delay(1000);
        //motor no gira
        digitalWrite(IN1, LOW);
        digitalWrite(led, LOW);
        delay(3000);
        break;
    }
  }
  //////////////////////////////////////////////////////////////////Boton de 3 a 1
  if (key) {
    switch (key)
    {
      case '3'://Cuando key B es oprimida.
        Serial.println("3");// el monitor serial escribe visitanos
        // Motor gira en sentido inverso
        digitalWrite (IN1, HIGH);
        digitalWrite (IN2, LOW);
        numeroTres();
        delay(2000);
        //motor no gira
        digitalWrite(IN1, LOW);
        digitalWrite(led, LOW);
        delay(3000);
        break;
    }
  }
  ///////////////////////////////////////////////////////////////// Boton de 4 a 2
  if (key) {
    switch (key)
    {
      case 'A'://Cuando key c es oprimida.
        Serial.println("4");// el monitor serial escribe visitanos

        // Motor gira en sentido inverso
        digitalWrite (IN1, HIGH);
        digitalWrite (IN2, LOW);
        numeroCuatro();
        delay(3000);
        //motor no gira
        digitalWrite(IN1, LOW);
        digitalWrite(led, LOW);
        delay(3000);
        break;
    }
  }
  ///////////////////////////////////////////////////////////Boton de 3 a 2
  if (key) {
    switch (key)
    {
      case '4'://Cuando key D es oprimida.
        Serial.println("1");// el monitor serial escribe visitanos

        // Motor gira en sentido inverso
        digitalWrite (IN2, HIGH);
        digitalWrite (IN1, LOW);
        numeroUno();
        delay(1000);
        //motor no gira
        digitalWrite(IN2, LOW);
        digitalWrite(led, LOW);
        delay(3000);
        break;
    }
  }
  /////// Boton de 4 a 3
  ///////////////////////////////////////////////////////////Boton B
  if (key) {
    switch (key)
    {
      case '6'://Cuando key B es oprimida.
        Serial.println("3");// el monitor serial escribe visitanos

        // Motor gira en sentido inverso
        digitalWrite (IN1, HIGH);
        digitalWrite (IN2, LOW);
        numeroTres();
        delay(1000);
        //motor no gira
        digitalWrite(IN1, LOW);
        digitalWrite(led, LOW);
        delay(3000);
        break;
    }
  }
  /////////////////////////////////////////////////////////// Numeros
  if (key) {
    switch (key)
    {
      case 'B':
        Serial.println("4");
        // Motor no gira
        digitalWrite (IN1, HIGH);
        digitalWrite (IN2, LOW);
        numeroCuatro();
        delay(3000);
        //motor no gira
        digitalWrite(IN1, LOW);
        digitalWrite(led, LOW);
        delay(3000);
        break;
    }
  }
  if (key) {
    switch (key)
    {
      case '7':
        Serial.println("1");
        numeroUno();
        // Motor gira en un sentido
        digitalWrite(IN2, HIGH);
        digitalWrite(IN1, LOW);
        delay(2000);
        //motor no gira
        digitalWrite(IN2, LOW);
        digitalWrite(led, LOW);
        delay(3000);
        break;
    }
  }
  if (key) {
    switch (key)
    {
      case '8':
        Serial.println("2");
        numeroDos();
        // Motor gira en un sentido
        digitalWrite(IN2, HIGH);
        digitalWrite(IN1, LOW);
        delay(1000);
        //motor no gira
        digitalWrite(IN2, LOW);
        digitalWrite(led, LOW);
        delay(3000);
        break;
    }
  }
  if (key) {
    switch (key)
    {
      case 'C':
        Serial.println("4");
        numeroCuatro();
        // Motor gira en un sentido
        digitalWrite(IN1, HIGH);
        digitalWrite(IN2, LOW);
        delay(1000);
        //motor no gira
        digitalWrite(IN1, LOW);
        digitalWrite(led, LOW);
        delay(3000);
        break;
    }
  }

  //Boton del 1 al 4
  if (key) {
    switch (key)
    {
      case '*':
        Serial.println("1");
        numeroUno();
        // Motor gira en un sentido
        digitalWrite(IN2, HIGH);
        digitalWrite(IN1, LOW);
        delay(3000);
        //motor no gira
        digitalWrite(IN2, LOW);
        digitalWrite(led, LOW);
        delay(3000);
        break;
    }
  }

  //Boton del 1 al 3
  if (key) {
    switch (key)
    {
      case '0':
        Serial.println("2");
        numeroDos();
        // Motor gira en un sentido
        digitalWrite(IN2, HIGH);
        digitalWrite(IN1, LOW);
        delay(2000);
        //motor no gira
        digitalWrite(IN2, LOW);
        digitalWrite(led, LOW);
        delay(3000);
        break;
    }
  }

  //Boton del 2 al 4
  if (key) {
    switch (key)
    {
      case '#':
        Serial.println("3");
        numeroTres();
        // Motor gira en un sentido
        digitalWrite(IN2, HIGH);
        digitalWrite(IN1, LOW);
        delay(1000);
        //motor no gira
        digitalWrite(IN2, LOW);
        digitalWrite(led, LOW);
        delay(3000);
        break;
    }
  }
  ////...
}

//Metodo para los numeros del display
void numeroUno() {
  //1
  digitalWrite(num1, LOW);
  digitalWrite(num2, HIGH);
  digitalWrite(num3, HIGH);
  digitalWrite(num4, HIGH);
  digitalWrite(num5, LOW);
  digitalWrite(num6, HIGH);
  digitalWrite(num7, HIGH);

  //led
  digitalWrite(led, HIGH);
  digitalWrite(luz1, HIGH);
}

void numeroDos() {
  //2
  digitalWrite(num1, HIGH);
  digitalWrite(num2, LOW);
  digitalWrite(num3, LOW);
  digitalWrite(num4, HIGH);
  digitalWrite(num5, LOW);
  digitalWrite(num6, LOW);
  digitalWrite(num7, LOW);

  //led
  digitalWrite(led, HIGH);
  digitalWrite(luz2, HIGH);
}

void numeroTres() {
  //3
  digitalWrite(num1, LOW);
  digitalWrite(num2, HIGH);
  digitalWrite(num3, LOW);
  digitalWrite(num4, HIGH);
  digitalWrite(num5, LOW);
  digitalWrite(num6, LOW);
  digitalWrite(num7, LOW);

  //led
  digitalWrite(led, HIGH);
  digitalWrite(luz3, HIGH);
}

void numeroCuatro() {
  //4
  digitalWrite(num1, LOW);
  digitalWrite(num2, HIGH);
  digitalWrite(num3, HIGH);
  digitalWrite(num4, LOW);
  digitalWrite(num5, LOW);
  digitalWrite(num6, HIGH);
  digitalWrite(num7, LOW);

  //led
  digitalWrite(led, HIGH);
  digitalWrite(luz4, HIGH);
}
3

Calma ya puse el codigo.
Solo tenia que esperar 5 min. Ahora bien te explico cuando yo presione la 2 por ejemplo el ascensor subo por decirte 3 segundos. En lugar de eso yo quiero que cuando presione la tecla 2 dos el ascensor suba hasta que el final de carrera del piso dos se active

4

tu código esta lleno de delay() ve aprendiendo que cualquier código de control (ni hablar con un ascensor) debe prescindir de su uso.
Delay detiene el código por el tiempo que le dices, veo case donde tienes 2 + 3 segundos o sea 5 segundos que el ascensor se mueve y ya pudo detectar que esta en un piso.
Estoy exagerando pero... se entiende la idea.

En su defecto se usa millis() y se programa de otro modo.

Ve a Documentación => Indice de temas tutoriales => millis() y máquina de de estados.
tal vez no entiendas nada o si, pero te dará una base de conocimiemto.

Si quieres ayuda los que solemos responder usamos millis() no delay() bueno siempre hay alguno que lo usa y lo justifica pero tiene pocos momentos para hacerlo.
Este por ejemplo no es uno.

Además tu código no tiene comentarios. No sabemos cuales son tus fines de carrera.

Cuando expones algo debes hacerlo de modo que los demás podamos entender no que tengamos que ser detectives para comprender un código porque si es asi, pasamos por alto este hilo hasta que por el post 15 mas o menos, vemos que se exponen todas los elementos y entonces ahi si se comprende y podemos ayudar.

Espero lo entiendas.

Te he puesto las normas del foro por privado. Espero las leas.

5

Buenas Espero que estén bien chicos necesito ayuda con este código acá te explico el funcionamiento

  • Controlo un motor con un teclado matricial 4x4
  • Cuando presiono la tecla dos el motor gira 3 segundos
  • Tengo un botón configurado como entrada al pin 22 de arduino MEGA

por razones de estrés :slight_smile: :slight_smile: amigos he omitido partes del código que son irrelevantes y te dejo solo lo que realmente importa una vez SOLUCIONADO MI PROBLEMA COMPARTIRE EL CODIGO COMPLETO

Ahora si viene la explicación larga lo que quiero que me ayuden amigos es que en lugar de que el motor se apague a los tres segundos este motor se apaga un segundo después que el botón se active

const int boton1 = 22;
 int value = 0;

#include<Keypad.h>

//motor
int IN1 = 3;
int IN2 = 2;
//teclado
const byte ROWS = 4;
const byte COLS = 4;
char keys[ROWS][COLS] = {
  {'1', '2', '3', 'A'},
  {'4', '5', '6', 'B'},
  {'7', '8', '9', 'C'},
  {'*', '0', '#', 'D'}
};
byte rowPins[ROWS] = {12, 11, 10, 9}; //Filas(pines del 9 al 6)
byte colPins[COLS] = {8, 7, 6, 5}; //Columnas (pines del 5 al)
Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );
void setup() {
 
  //motor
  pinMode (IN1, OUTPUT);    // Input4 conectada al pin
  pinMode (IN2, OUTPUT);    // Input3 conectada al pin
    pinMode (boton1, INPUT);
}

void loop() {
  
  char key = keypad.getKey();
  if (key != 0)     // Si el valor es 0 es que no se ha pulsado ninguna tecla
    Serial.println(key);
  if (key) {
    switch (key)
    {
      case '2'://Cuando key 2 es oprimida
        Serial.println("2");// el monitor serial escribe 2
        // Motor gira en sentido inverso
        digitalWrite (IN1, HIGH);
        digitalWrite (IN2, LOW);
        numeroDos();
        delay(3000); // tres segundos que el motor esta activado
        //motor no gira
        digitalWrite(IN1, LOW);
        digitalWrite(led, LOW);
        delay(3000);
        break;
    }
  }

}

ayúdenme solamente a agregar unas lineas de código para que haga lo que explique anteriormente
he tratado de ser lo mas explicado posible y de cumplir todas las normas del foro

6

El uso de delay()
Pero el principal es que la variable key es local y haces esto:
Encender motor (apenas durará) y acto seguido lo sometes a 3 segundos de pausa.
Lo que necesitas es que el estado sea Activo durante "X" tiempo y Parado "Y" tiempo.
Cómo además usas leds lo suyo sería usar timers. Si no sabes consulta en la documentación del foro timers usando millis()

amigo se que no te gusta usar delay razón por la que quiero eliminar la parte donde dice delay ahora apagar el motor cuando el botón se active

en lo demás todo esta en perfecto estado tengo que crear una sentencia if dentro de ora sentencia if para que cuando presione el numero dos active el motor y cuando presione el botón este motor se apague

como podria hacer esto???

7

Doble posteo.. y cuando revise espero no encontrar que este sea un triple posteo.
Este era el hilo similar
Consulta sobre motor y finales de carrera

Donde se te dió exactamente las mimas indicaciones respecto de delay() y demás.
Ahora uní todo en un solo tema y espero que no repitas la falta.
Da un repaso a las normas que te enviaré por privado ya que creo que no las comprendes.
Si abres un tema hasta darle finalizado no empiezas otro hilo con temática similar.
Muy simple no?
Y nada de que soy nuevo. Tienes mensajes del año 2016.

8

A ver si esto impulsa tu problema.
Problema numero 1) eliminar los delay()

Con los delays eliminados y un código fluido nos ponemos a mirar los finales de carrera. Completa la tarea, porque solo lo hice para el primer case

#include <Keypad.h>

//motor
const byte IN1  = 3;
const byte IN2  = 2;
//teclado
const byte ROWS = 4;
const byte COLS = 4;

char keys[ROWS][COLS] = {
  {'1', '2', '3', 'A'},
  {'4', '5', '6', 'B'},
  {'7', '8', '9', 'C'},
  {'*', '0', '#', 'D'}
};

byte rowPins[ROWS] = {12, 11, 10, 9}; //Filas(pines del 9 al 6)
byte colPins[COLS] = {8, 7, 6, 5}; //Columnas (pines del 5 al)
Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );

//led
const byte led  = 13;
//display
const byte num1 = A0;
const byte num2 = A1;
const byte num3 = A2;
const byte num4 = A3;
const byte num5 = A4;
const byte num6 = A5;
const byte num7 = A6;

const byte luz1 = 22;
const byte luz2 = 24;
const byte luz3 = 26;
const byte luz4 = 28;

byte estado = 0;
char key, keyAnt;

void setup() {
  //motor
  pinMode (IN1, OUTPUT);    // Input4 conectada al pin
  pinMode (IN2, OUTPUT);    // Input3 conectada al pin

  pinMode (num1, OUTPUT);
  pinMode (num2, OUTPUT);
  pinMode (num3, OUTPUT);
  pinMode (num4, OUTPUT);
  pinMode (num5, OUTPUT);
  pinMode (num6, OUTPUT);
  pinMode (num7, OUTPUT);

  pinMode (luz1, OUTPUT);
  pinMode (luz2, OUTPUT);
  pinMode (luz3, OUTPUT);
  pinMode (luz4, OUTPUT);

  Serial.begin (9600);
}

//// VOID LOOP //////////////
void loop() {

  key = keypad.getKey();
  if (key != NOKEY) {     // Si el valor es 0 es que no se ha pulsado ninguna tecla
    Serial.println(key);
    if (key != keyAnt)
        estado = 0;
    switch (key) {
      case '2': switch(estado) {  // Cuando key A es oprimida.. de 4 a 1.
                  case 0: Serial.println("2");// el monitor serial escribe ascensor
                          sentido_inverso();
                          numeroDos();
                          estado = 1;
                          start = millis();
                          break;
                  case 1: if (millis() - start > 1000UL) {
                              stop();
                              estado = 2;
                              start = millis();
                          }
                          break;
                  case 2: if (millis() - start > 3000UL) {
                              estado = 0;
                          }
                          break;
                }

      // repetir esto switch case en cada case de acá hasta el final
      
      //////////////////////////////////////////////////////////////////Boton de 3 a 1
      case '3': // Cuando key B es oprimida.
                Serial.println("3");// el monitor serial escribe visitanos
                sentido_inverso();
                numeroTres();
                delay(2000);
                stop();
                delay(3000);
                break;
      ///////////////////////////////////////////////////////////////// Boton de 4 a 2
      case 'A': // Cuando key c es oprimida.
                Serial.println("4");// el monitor serial escribe visitanos
                sentido_inverso();
                numeroCuatro();
                delay(3000);
                stop();
                delay(3000);
                break;
      case '4': // Cuando key D es oprimida.
                Serial.println("1");// el monitor serial escribe visitanos
                sentido_inverso();
                numeroUno();
                delay(1000);
                stop();
                delay(3000);
                break;
      ///////////////////////////////////////////////////////////Boton B
      case '6': // Cuando key B es oprimida.
                Serial.println("3");// el monitor serial escribe visitanos
                sentido_inverso();
                numeroTres();
                delay(1000);
                stop();
                delay(3000);
                break;
      case 'B': Serial.println("4");
                stop();
                numeroCuatro();
                delay(3000);
                stop();
                delay(3000);
                break;
      case '7': Serial.println("1");
                numeroUno();
                sentido_directo();
                delay(2000);
                stop();
                delay(3000);
                break;
      case '8': Serial.println("2");
                numeroDos();
                sentido_directo();
                delay(1000);
                stop();
                delay(3000);
                break;
      case 'C': Serial.println("4");
                numeroCuatro();
                sentido_directo();
                delay(1000);
                stop();
                delay(3000);
                break;
      case '*': Serial.println("1");
                numeroUno();
                sentido_directo();
                delay(3000);
                stop();
                delay(3000);
                break;
      case '0': Serial.println("2");
                numeroDos();
                sentido_directo();
                delay(2000);
                stop();
                delay(3000);
                break;
      case '#':
                Serial.println("3");
                numeroTres();
                sentido_directo();
                delay(1000);
                stop();
                delay(3000);
                break;
    }
    keyAnt = key;
  }
}

//Metodo para los numeros del display
void numeroUno() {
  //1
  digitalWrite(num1, LOW);
  digitalWrite(num2, HIGH);
  digitalWrite(num3, HIGH);
  digitalWrite(num4, HIGH);
  digitalWrite(num5, LOW);
  digitalWrite(num6, HIGH);
  digitalWrite(num7, HIGH);

  //led
  digitalWrite(led, HIGH);
  digitalWrite(luz1, HIGH);
}

void numeroDos() {
  //2
  digitalWrite(num1, HIGH);
  digitalWrite(num2, LOW);
  digitalWrite(num3, LOW);
  digitalWrite(num4, HIGH);
  digitalWrite(num5, LOW);
  digitalWrite(num6, LOW);
  digitalWrite(num7, LOW);

  //led
  digitalWrite(led, HIGH);
  digitalWrite(luz2, HIGH);
}

void numeroTres() {
  //3
  digitalWrite(num1, LOW);
  digitalWrite(num2, HIGH);
  digitalWrite(num3, LOW);
  digitalWrite(num4, HIGH);
  digitalWrite(num5, LOW);
  digitalWrite(num6, LOW);
  digitalWrite(num7, LOW);

  //led
  digitalWrite(led, HIGH);
  digitalWrite(luz3, HIGH);
}

void numeroCuatro() {
  //4
  digitalWrite(num1, LOW);
  digitalWrite(num2, HIGH);
  digitalWrite(num3, HIGH);
  digitalWrite(num4, LOW);
  digitalWrite(num5, LOW);
  digitalWrite(num6, HIGH);
  digitalWrite(num7, LOW);

  //led
  digitalWrite(led, HIGH);
  digitalWrite(luz4, HIGH);
}

void stop() {
  //motor no gira
  digitalWrite(IN2, LOW);
  digitalWrite(led, LOW);
}

void sentido_directo() {
  // Motor gira en un sentido
  digitalWrite(IN2, HIGH);
  digitalWrite(IN1, LOW);
}

void sentido_inverso() {
  // Motor gira en un sentido
  digitalWrite(IN2, HIGH);
  digitalWrite(IN1, LOW);
}
9

ya lo habian comentado, y es que falta algo, alguna global o flag por usar la variable local.
Si quitas los delay() esos intervalos con millis() que te puso el moderador no seran efectivos hasta pulsar otra tecla porque se ejecutan esas lineas al entrar en if() con el key.

Tu código hace esto porque al poner delay paras, pero delay es el segundo problema.
Es usar millis() y guardar la tecla pulsada para que despues se entre en la condición y evalue los timers.

No se si me explico. Me quedo con lo que argumenta aduMyth.

10

Te responde @bitebyte.
Lo que le puse fue como modificar cada case pero solo modifiqué el primero porque es mucho trabajo y mucho tiempo PERSONAL y he visto que ultimamente el tiempo no se agradece asi que cambié de táctica.
Asi que muestro la idea. Tiene que cambiar todos los demas.

Se supone que eso fue lo que le entregue no 10 cases con delay que si lees antes verás qeu le hemos indicado varios foreros que es la razón de su problema.

Ahora si miras el código tiene muchos mas errores pero bueno, como dije empecemos por estos.

11

Bueno Chicos hasta aquí dejo mi post voy a dar como cerrado este debate al principio buscaba un poco de ayuda para este novato a decir verdad es que soy muy curioso y un poco travieso eso me ha metido en uno que otro lió la verdad es que si me ayudaron ahora pude hacer mi código mas eficiente saben Me encanta programar arduino la es que las cosas que se las aprendí por mi propia cuenta Y eso me hace un programador Feliz

PD: surbyte me descubrió