Controlar giro de un motor con pulsadores o mover un motor a HOME

Hola amigos, antes de nada me gustaría decir que soy novato, novato total con arduino, pero se me ha metido en la cabeza hacer un slider motorizado para Timelapse y estoy a medio camino. Estoy usando arduino UNO, un shield V3 para 4 drivers (solo usaré uno)y el driver A4988 de Pololu.
A ver si consigo explicarme y que me entendáis.
Quiero dejar claro que no deseo que me deis la solución definitiva, sino, una ayudita para orientarme y guiarme el camino correcto.

Para mover el motor, estoy usando un código tal como este que muestro.

 { 
    digitalWrite(reset, LOW);
  digitalWrite(direccion, LOW);  
  for (int i = 0; i<(pasos); i++)
    {
    pot=analogRead(A0)
    pot = map(pot, 0, 1023, minimo, maximo);
    digitalWrite(steps, HIGH); 
    digitalWrite(steps, LOW); 
    delayMicroseconds(VELOCIDAD);
    }
  
  delayMicroseconds(10);

La velocidad la regulo con el potenciometro que va perfecto. Tengo una instrucción "if" para seleccionar 2 modos de trabajo (alta velocidad (30min) y baja velocidad (8 horas))

El primer problema que me encuentro es que no consigo mover el motor un numero determinado de pasos, en concreto 38400 (3200 pasos x 12 vueltas )con MS1, MS2 y MS3 HIGH . Al usar "int" no deja valores mayores de 32767, por lo que uso dos ciclos separados por 10 milisegundos para recorrer el carril completo. Si uso "unsigned int" se me sale del carril. ¿Hay alguna solución?

Lo segundo y mas importante es que no consigo usar los pulsadores como fin de carrera. Si inicio el sistema con el carro a mitad de camino se sale, ya que está programado para recorrerlo entero. ¿Como puedo programar el fin de carrera? Y ya sería la leche si al tocar el pulsador "away" el carro volviera a "Home"

En fin, siento haber soltado este repertorio, pero después de mucho, mucho probar y estar dando palos de ciego no me queda otra que pedir ayuda. Espero que alguno de vosotros, tenga a bien echarme una manita, mientras tanto, y para no perder las buenas costumbres, voy a seguir probando y buscando posibles soluciones.

Muchas gracias a todos de antemano.

El primer problema que me encuentro es que no consigo mover el motor un numero determinado de pasos, en concreto 38400 (3200 pasos x 12 vueltas )con MS1, MS2 y MS3 HIGH . Al usar "int" no deja valores mayores de 32767, por lo que uso dos ciclos separados por 10 milisegundos para recorrer el carril completo. Si uso "unsigned int" se me sale del carril. ¿Hay alguna solución?

Usa unsigned int y tendrás de 0 a 65535.
Qué es salirse del carril? Recuerda que acá respondemos personas de todas las nacionalidades, y no todos entendemos los regionalismos. Asi que el español mas neutro es lo mejor para entendernos.
No entiendo porque unsigned int no es una alternativa cuando ES LA alternativa.

o segundo y mas importante es que no consigo usar los pulsadores como fin de carrera. Si inicio el sistema con el carro a mitad de camino se sale, ya que está programado para recorrerlo entero. ¿Como puedo programar el fin de carrera? Y ya sería la leche si al tocar el pulsador "away" el carro volviera a "Home"

De nuevo, hablas como si todos estuviéramos trabajando contigo desde hace semanas y supiéramos que es away, que es home, etc, etc.
No veo una explicación tuya donde expliques de qué hablas.

Intenta contar todo, explicar que hará el motor, por donde se desplaza. Explica el contexto de todo el proyecto y si es gráfico mejor, pero de ese modo podremos responderte los que ahora no te entendemos.

surbyte:
De nuevo, hablas como si todos estuviéramos trabajando contigo desde hace semanas y supiéramos que es away, que es home, etc, etc.
No veo una explicación tuya donde expliques de qué hablas.

Intenta contar todo, explicar que hará el motor, por donde se desplaza. Explica el contexto de todo el proyecto y si es gráfico mejor, pero de ese modo podremos responderte los que ahora no te entendemos.

Está claro que no he sido lo suficientemente explicito. Pero que quede claro que no ha sido mi intención. Todo lo contrario, he tratado de explicarlo de un modo resumido para que se entendiese lo mejor posible. De todos modos, trataré de aclarar un poco mas.

El proyecto es un slider motorizado, que es una plataforma donde colocar la cámara que se desplaza por un carril de unos 150 cm. El motor tiene un movimiento de derecha a izquierda. Durante ese movimiento la cámara estará tomando fotos. Normalmente se puede regular para que tarde en recorrer el carril hasta 8 horas. Se trata de que cuando llegue al final del recorrido y pulse el pulsador, el motor se pare o cambie de sentido hasta llegar a su lugar de origen, donde se parará. Pero ya digo, si llega al final del rail y se detiene también sería válido.

surbyte:
Usa unsigned int y tendrás de 0 a 65535.
Qué es salirse del carril? Recuerda que acá respondemos personas de todas las nacionalidades, y no todos entendemos los regionalismos. Asi que el español mas neutro es lo mejor para entendernos.
No entiendo porque unsigned int no es una alternativa cuando ES LA alternativa.

Si uso " unsignet int" con un valor 32767 (pasos de motor) lo hace perfecto el motor de para cuando llega a ese numero de pasos, pero si el valor es mayor, el motor no para, osea no da un paso mas, sino que sigue en marcha y llega al final del carril llegando a chocar. El numero de pasos para recorrer el carril entero es de 38400.
Pero esto lo solucionaría si pudiese poner en marcha el motor de modo indefinido y retornase al llegar al final del carril.

Bueno pero entonces el problema es que la librería que toma los pasos no soporta unsigned int, simple!!!
Por otra parte, veo que has leído las normas pero no has puesto todo el código.
Asi que no se que librería usas.
Puedes ampliar la información?
Vas bien pero esfuérzate un poco mas. Coloca el código si pretendes que te ayudemos, de lo contrario lo resuelves tu solo.
Si lees las normas, dicen claramente, proveer la información como bien hiciste la segunda vez, mas códigos, esquemas y todo lo que ayude a la comprensión del problema.
Ahora para resolver tu problema de código hay que verlo completo.

boolean mode = false;
int SW1 = 3;
int SW2 = 4;
int SWMODE = 6;
int pot;
int steps = 2;       //Posición del pin contador de pasos
int direccion = 5;    //Posición del pin dirección
int reset = 8;       //Posición del reset
unsigned int pasos = 19200;     //Cantidad de pasos a meter.
int minimo = 50;     //velocidad maxima. 110 = 10 seg en recorrer el rail
int maximo = 750;    //velocidad minima. 4500 = 180 seg en recorrer el rail. 2500 = 100 seg. 1500 = 63 seg.

/*
 * 3200 equivale a una vuelta de motor. COmo estan activados M1, M2 y M3 cada micropaso es 1/16 pasos. Por lo tanto si 200 pasos son una vuelta, con esta configuración será 16*200=3200
 */
 
// La rutina de inicialización
void setup()
{               
  // initialize the digital pin as an output.
  pinMode(steps, OUTPUT);
  pinMode(direccion, OUTPUT);
  pinMode(reset, OUTPUT);
  pinMode(SW1, INPUT);
  pinMode(SW2, INPUT);
  pinMode(SWMODE, INPUT);
    delay(100);
    digitalWrite(reset, HIGH);   //Cuando reset se encuentre en LOW el motor arrancará y leerá los comandos enviados.
     digitalWrite(direccion, LOW);  
      for (int i = 0; i<20; i++)       //Equivale al numero de vueltas (200 es 360º grados) o micropasos
      {
       digitalWrite(steps, HIGH);  // This LOW to HIGH change is what creates the
       digitalWrite(steps, LOW); // al A4988 de avanzar una vez por cada pulso de energia. 
       delayMicroseconds(300);     // Regula la velocidad, cuanto mas bajo mas velocidad.
      }
}
// La rutina que se repite cíclicamente
void loop()
{
 if (digitalRead(SWMODE) == HIGH) //Con SWMODE seleccionaremos alta o baja velocidad. Dependiendo de la selección realizará un ciclo u otro. delay o delaymicroseconds
    {
    mode = true;
    }
    if (mode == true)
    //------------------------------------------------------------------------------CICLO1-IDA
    { 
      digitalWrite(reset, HIGH);    //Mientras reset este en HIGH el motor permanecerá apagado y no sufrirá. El chip apagará todos los puertos y no leerá comandos.
      delay(2000);
      digitalWrite(reset, LOW);   //Cuando reset se encuentre en LOW el motor arrancará y leerá los comandos enviados.
      digitalWrite(direccion, LOW);  
      //Se repite un bucle hasta final de carril.
        for (int i = 0; i<pasos; i++)       //Equivale al numero de vueltas (200 es 360º grados) o micropasos
        {
        pot=analogRead(A0); //Lectura potenciómetro
        pot = map(pot, 0, 1023, minimo, maximo); //Establecemos la velocidad entre 30 y 150 rpm
        // Con el pot aqui variamos la velocidad, incluso cuando esté en movimiento.
        digitalWrite(steps, HIGH);  
        digitalWrite(steps, LOW);  
        delayMicroseconds(pot);     // Regula la velocidad, cuanto mas bajo mas velocidad.
        }
      delayMicroseconds(10);
      //--------------------------------------------------------------------------CICLO2-IDA
      digitalWrite(direccion, LOW);  
      //Se repite un bucle hasta final de carril.
        for (int i = 0; i<pasos; i++)       //Equivale al numero de vueltas (200 es 360º grados) o micropasos
        {
        //tenemos que repetir el mismo coclo de steps y direccion que no acepta valores de mas de 32767. En este caso, ponemos dos ciclos de 19200 que es lo que tiene el "int" pasos
        pot=analogRead(A0); //Lectura potenciómetro
        pot = map(pot, 0, 1023, minimo, maximo); //Establecemos la velocidad entre 30 y 150 rpm
        // Con el pot aqui variamos la velocidad, incluso cuando esté en movimiento.
    digitalWrite(steps, HIGH);  
    digitalWrite(steps, LOW); 
    delayMicroseconds(pot);     // Regula la velocidad, cuanto mas bajo mas velocidad.
    }
    digitalWrite(reset, HIGH);   //Mientras reset este en HIGH el motor permanecerá apagado y no sufrirá. El chip apagará todos los puertos y no leerá comandos.
    delay(2000);
      //------------------------------------------------------------------------CICLO1-VUELTA
      
  digitalWrite(reset, LOW);   //Cuando reset se encuentre en LOW el motor arrancará y leerá los comandos enviados.
  digitalWrite(direccion, HIGH);
    for (int i = 0; i<pasos; i++)       //Equivale al numero de vueltas (200 es 360º grados) o micropasos
    {  
    pot=analogRead(A0); //Lectura potenciómetro
    pot = map(pot, 0, 1023, minimo, maximo); //Establecemos la velocidad entre min y max
    digitalWrite(steps, LOW);   
    digitalWrite(steps, HIGH);    
    delayMicroseconds(pot);         // Regula la velocidad, cuanto mas bajo mas velocidad.
    }
    delayMicroseconds(10);
    //-------------------------------------------------------------------------CICLO2-VUELTA
  digitalWrite(direccion, HIGH);
    for (int i = 0; i<pasos; i++)       //Equivale al numero de vueltas (200 es 360º grados) o micropasos
    {  
    pot=analogRead(A0); //Lectura potenciómetro
    pot = map(pot, 0, 1023, minimo, maximo); //Establecemos la velocidad entre min y max
    digitalWrite(steps, LOW);   
    digitalWrite(steps, HIGH);    
    delayMicroseconds(pot);         // Regula la velocidad, cuanto mas bajo mas velocidad.
    } 
    }
    //--------------------------------------------------------------------------------------FIN CICLO ALTA VELOCIDAD
    //--------------------------------------------------------------------------------------INICIO CICLO BAJA VELOCIDAD
  if (mode == false)
      {
   digitalWrite(reset, HIGH);    //Mientras reset este en HIGH el motor permanecerá apagado y no sufrirá. El chip apagará todos los puertos y no leerá comandos.
      delay(2000);
      digitalWrite(reset, LOW);   //Cuando reset se encuentre en LOW el motor arrancará y leerá los comandos enviados.
      digitalWrite(direccion, LOW);  
      //Se repite un bucle hasta final de carril.
        for (int i = 0; i<pasos; i++)       //Equivale al numero de vueltas (200 es 360º grados) o micropasos
        {
        pot=analogRead(A0); //Lectura potenciómetro
        pot = map(pot, 0, 1023, minimo, maximo); //Establecemos la velocidad entre 30 y 150 rpm
        // Con el pot aqui variamos la velocidad, incluso cuando esté en movimiento.
        digitalWrite(steps, HIGH);  
        digitalWrite(steps, LOW);  
        delay(pot);     // Regula la velocidad, cuanto mas bajo mas velocidad.
        }
      delayMicroseconds(10);
      //--------------------------------------------------------------------------CICLO2-IDA
      digitalWrite(direccion, LOW);  
      //Se repite un bucle hasta final de carril.
        for (int i = 0; i<pasos; i++)       //Equivale al numero de vueltas (200 es 360º grados) o micropasos
        {
        //tenemos que repetir el mismo coclo de steps y direccion que no acepta valores de mas de 32767. En este caso, ponemos dos ciclos de 19200 que es lo que tiene el "int" pasos
        pot=analogRead(A0); //Lectura potenciómetro
        pot = map(pot, 0, 1023, minimo, maximo); //Establecemos la velocidad entre 30 y 150 rpm
        // Con el pot aqui variamos la velocidad, incluso cuando esté en movimiento.
    digitalWrite(steps, HIGH);  
    digitalWrite(steps, LOW); 
    delay(pot);     // Regula la velocidad, cuanto mas bajo mas velocidad.
    }
    digitalWrite(reset, HIGH);   //Mientras reset este en HIGH el motor permanecerá apagado y no sufrirá. El chip apagará todos los puertos y no leerá comandos.
    delay(2000);
      //------------------------------------------------------------------------CICLO1-VUELTA
      
  digitalWrite(reset, LOW);   //Cuando reset se encuentre en LOW el motor arrancará y leerá los comandos enviados.
  digitalWrite(direccion, HIGH);
    for (int i = 0; i<pasos; i++)       //Equivale al numero de vueltas (200 es 360º grados) o micropasos
    {  
    pot=analogRead(A0); //Lectura potenciómetro
    pot = map(pot, 0, 1023, minimo, maximo); //Establecemos la velocidad entre min y max
    digitalWrite(steps, LOW);   
    digitalWrite(steps, HIGH);    
    delay(pot);         // Regula la velocidad, cuanto mas bajo mas velocidad.
    }
    delayMicroseconds(10);
    //-------------------------------------------------------------------------CICLO2-VUELTA
  digitalWrite(direccion, HIGH);
    for (int i = 0; i<pasos; i++)       //Equivale al numero de vueltas (200 es 360º grados) o micropasos
    {  
    pot=analogRead(A0); //Lectura potenciómetro
    pot = map(pot, 0, 1023, minimo, maximo); //Establecemos la velocidad entre min y max
    digitalWrite(steps, LOW);   
    digitalWrite(steps, HIGH);    
    delay(pot);         // Regula la velocidad, cuanto mas bajo mas velocidad.   
   }
}
}

Para mi que soy un novatisimo en la materia no lo veo nada claro. Pensé que unsigned int era una función básica y estaría incluida por defecto. Además, ¿no daría error al compilar??

y por otra parte ahí va el código completo. Ahora mismo lo que hace es ir a un lado a otro del carril continuamente. No tengo nada conectado, tan solo el A4988, el motor PaP, un switch a la entrada 6 del arduino que selecciona la velocidad, y enable en el pin 8. De momento no tengo pulsadores de final de carrera por que no se como configurarlos en el scketch.
Aviso, seguramente me digáís que todo este scketch se puede reducir, pero .......... ya digo soy novato y me lo he ido currando a base de ensayo-error. Así se aprende.

Pues si ,se puede reducir y mucho si no reinventas la rueda y usas librerias como stepper (viene de serie con el ide) o accelstepper (busca en google).Para los finales de carrera puedes usar microinterruptores como los de las impresoras 3d ,entonces cada vez que enciendas el arduino ,ejecutas una rutina de posicionado (mover el motor un numero corto de pasos y comprobar si se ha pulsado el micro,mover y comprobar...asi hasta que corte el micro) ,entonces ,ese es tu home o 0 ,a partir de ahi ,si tu driver esta bien ajustado en intensidad y tu motor no pierde pasos ,siempre estaras en una posicion conocida (los pasos que va a moverse ,que almacenaras en una variable unsigned int o unsigned long para mas seguridad)

Estaba por decir lo mismo. Sigue el consejo de jose