Arduino nano y escudo rev. V3

Buenas¡ Después de mucho leer y batallar con este sketch, no consigo que el cuarto servo se mueva, he probado con sketch similares en los mismos pines y funcionan bien, pero con el mío no hay manera, y entiendo que es problema del sketch. He alimentado a 5v. y a 12v. Mi nivel es de principiante.
Agradeceria un ayuda.

[code]
#include <Servo.h>


// variables constants que s’utilitzen per establir angles de servo, en graus
const int straight1 = 90;
const int divergent1 = 120;
const int straight2 = 90;
const int divergent2 = 120;
const int straight3 = 90;
const int divergent3 = 120;
const int straight = 90;
const int divergent = 120;

// variables constants que contenen els identificadors dels pins que estem utilitzant
// Desvio 1
const int divergent_led1 = 1;
const int straight_led1 = 0;
const int buttonpin1 = A0;
const int servopin1 = 3;
// Desvio 2
const int divergent_led2 = 4;
const int straight_led2 = 2;
const int buttonpin2 = A1;
const int servopin2 = 5;
// Desvio 3
const int divergent_led3 = 11;
const int straight_led3 = 10;
const int buttonpin3 = A2;
const int servopin3 = 6;
// Desvio 4
const int divergent_led = 9;
const int straight_led = 7;
const int buttonpin4 = A3;
const int servopin4 = 8;

// retard de pas del moviment del servo, en mil·lisegons
const int step_delay = 70;

// crear un objecte servo
Servo myservo1;
Servo myservo2;
Servo myservo3;
Servo myservo4;

// variables globals per emmagatzemar la posició del servo
int pos1 = straight1; // actual
int old_pos1 = pos1; // previa
int pos2 = straight2; // actual
int old_pos2 = pos2; // previa
int pos3 = straight3; // actual
int old_pos3 = pos3; // previa
int pos = straight; // actual
int old_pos = pos; // previa


void setup()
{
//Desvio1  // estableix el mode dels pins digitals que s’utilitzen
  pinMode(buttonpin1, INPUT);
  pinMode(straight_led1, OUTPUT);
  pinMode(divergent_led1, OUTPUT);
//Desvio2  // estableix el mode dels pins digitals que s’utilitzen
  pinMode(buttonpin2, INPUT);
  pinMode(straight_led2, OUTPUT);
  pinMode(divergent_led2, OUTPUT);
//Desvio3  // estableix el mode dels pins digitals que s’utilitzen
  pinMode(buttonpin3, INPUT);
  pinMode(straight_led3, OUTPUT);
  pinMode(divergent_led3, OUTPUT);
//Desvio4  // estableix el mode dels pins digitals que s’utilitzen
  pinMode(buttonpin4, INPUT);
  pinMode(straight_led, OUTPUT);
  pinMode(divergent_led, OUTPUT);


  //Desvio 1  // configurar el servo
  myservo1.attach(servopin1);  // conectar el servo al pin 3
  myservo1.write(pos1); // posició inicial del servo
  //Desvio 2
  myservo2.attach(servopin2);  // conectar el servo al pin 3
  myservo2.write(pos2); // posició inicial del servo
  //Desvio 3  // configurar el servo
  myservo3.attach(servopin3);  // conectar el servo al pin 3
  myservo3.write(pos3); // posició inicial del servo
  //Desvio 4
  myservo4.attach(servopin4);  // conectar el servo al pin 3
  myservo4.write(pos); // posició inicial del servo


  //Desvio 1  // estableix el estat inicial dels led
  digitalWrite(straight_led1, HIGH);
  digitalWrite(divergent_led1, LOW);
  //Desvio 2  // estableix el estat inicial dels led
  digitalWrite(straight_led2, HIGH);
  digitalWrite(divergent_led2, LOW);
  //Desvio 3  // estableix el estat inicial dels led
  digitalWrite(straight_led3, HIGH);
  digitalWrite(divergent_led3, LOW);
  //Desvio 4  // estableix el estat inicial dels led
  digitalWrite(straight_led, HIGH);
  digitalWrite(divergent_led, LOW);

}

void loop()
{
  // inicieu cada iteració del bucle llegint el botó
  // si es prem el botó (es llegeix ALT), mou el servo
  ////Desvio 1///
  int button_state1 = digitalRead(buttonpin1);
  if (button_state1 == HIGH) {
    // apagueu el led encès
    if (pos1 == straight1) {
      digitalWrite(straight_led1, LOW);
    } else {
      digitalWrite(divergent_led1, LOW);
    }
    old_pos1 = pos1;   // desar la posició actual

    // Alternar la posició al valor oposat
    pos1 = pos1 == straight1 ? divergent1 : straight1;

    // Mou el servo a la seva nova posició
    if (old_pos1 < pos1) { // si el nou angle és més gran
      // augmenta la posició del servo de old_pos to pos
      for (int i = old_pos1 + 1; i <= pos1; i++) {
        myservo1.write(i); // escriu la posició següent al servo
        delay(step_delay); // espera
      }
    } else {  // en cas contrari, el nou angle és igual o inferior
      // disminueix la posició del servo de oldpos a pos
      for (int i = old_pos1 - 1; i >= pos1; i--) {
        myservo1.write(i); // escriu la següent posició al servo
        delay(step_delay); // espera
      }
    }
    // encén el LED adequat.
    if (pos1 == straight1) {
      digitalWrite(straight_led1, HIGH);
    } else {
      digitalWrite(divergent_led1, HIGH);
    }

  }
  ////Desvio 2///
  int button_state2 = digitalRead(buttonpin2);
  if (button_state2 == HIGH) {
    // apagueu el led encès
    if (pos2 == straight2) {
      digitalWrite(straight_led2, LOW);
    } else {
      digitalWrite(divergent_led2, LOW);
    }
    old_pos2 = pos2;   // desar la posició actual

    // Alternar la posició al valor oposat
    pos2 = pos2 == straight2 ? divergent2 : straight2;

    // Mou el servo a la seva nova posició
    if (old_pos2 < pos2) { // si el nou angle és més gran
      // augmenta la posició del servo de oldpos to pos
      for (int i = old_pos2 + 1; i <= pos2; i++) {
        myservo2.write(i); // escriu la posició següent al servo
        delay(step_delay); // espera
      }
    } else {  // en cas contrari, el nou angle és igual o inferior
      // disminueix la posició del servo de oldpos a pos
      for (int i = old_pos2 - 1; i >= pos2; i--) {
        myservo2.write(i); // escriu la següent posició al servo
        delay(step_delay); // espera
      }
    }
    // encén el LED adequat.
    if (pos2 == straight2) {
      digitalWrite(straight_led2, HIGH);
    } else {
      digitalWrite(divergent_led2, HIGH);
    }

  }

  ////Desvio 3///
  int button_state3 = digitalRead(buttonpin3);
  if (button_state3 == HIGH) {
    // apagueu el led encès
    if (pos3 == straight3) {
      digitalWrite(straight_led3, LOW);
    } else {
      digitalWrite(divergent_led3, LOW);
    }
    old_pos3 = pos3;   // desar la posició actual

    // Alternar la posició al valor oposat
    pos3 = pos3 == straight3 ? divergent3 : straight3;

    // Mou el servo a la seva nova posició
    if (old_pos3 < pos3) { // si el nou angle és més gran
      // augmenta la posició del servo de oldpos to pos
      for (int i = old_pos3 + 1; i <= pos3; i++) {
        myservo3.write(i); // escriu la posició següent al servo
        delay(step_delay); // espera
      }
    } else {  // en cas contrari, el nou angle és igual o inferior
      // disminueix la posició del servo de oldpos a pos
      for (int i = old_pos3 - 1; i >= pos3; i--) {
        myservo3.write(i); // escriu la següent posició al servo
        delay(step_delay); // espera
      }
    }
    // encén el LED adequat.
    if (pos3 == straight3) {
      digitalWrite(straight_led3, HIGH);
    } else {
      digitalWrite(divergent_led3, HIGH);
    }
  ////Desvio 4///
  int button_state4 = digitalRead(buttonpin4);
  if (button_state4 == HIGH) {
    // apagueu el led encès
    if (pos == straight) {
      digitalWrite(straight_led, LOW);
    } else {
      digitalWrite(divergent_led, LOW);
    }
    old_pos = pos;   // desar la posició actual

    // Alternar la posició al valor oposat
    pos = pos == straight ? divergent : straight;

    // Mou el servo a la seva nova posició
    if (old_pos < pos) { // si el nou angle és més gran
      // augmenta la posició del servo de old_pos to pos
      for (int i = old_pos + 1; i <= pos; i++) {
        myservo4.write(i); // escriu la posició següent al servo
        delay(step_delay); // espera
      }
    } else {  // en cas contrari, el nou angle és igual o inferior
      // disminueix la posició del servo de oldpos a pos
      for (int i = old_pos - 1; i >= pos; i--) {
        myservo4.write(i); // escriu la següent posició al servo
        delay(step_delay); // espera
      }
    }
    // encén el LED adequat.
    if (pos == straight) {
      digitalWrite(straight_led, HIGH);
    } else {
      digitalWrite(divergent_led, HIGH);
    }

  }
  }
}
// final del bucle

[/code]

Yo simplificaría tu programa usando vectores o matrices de datos o incluso una estructura que albergue toda la información y luego en un loop recorro cada servo para que haga sus acciones.

He corregido solo para que el código tenga coherencia como lo venías haciendo con 1 2 y 3 y luego alteraste el patrón con 4.

#include <Servo.h>

// variables constants que s'utilitzen per establir angles de servo, en graus
const int straight1 	= 90;
const int divergent1 	= 120;
const int straight2 	= 90;
const int divergent2 	= 120;
const int straight3 	= 90;
const int divergent3 	= 120;
const int straight 		= 90;
const int divergent 	= 120;

// variables constants que contenen els identificadors dels pins que estem utilitzant
// Desvio 1
const int divergent_led1 	= 1;
const int straight_led1 	= 0;
const int buttonpin1 		= A0;
const int servopin1 		= 3;
// Desvio 2
const int divergent_led2 	= 4;
const int straight_led2 	= 2;
const int buttonpin2 		= A1;
const int servopin2 		= 5;
// Desvio 3
const int divergent_led3 	= 11;
const int straight_led3 	= 10;
const int buttonpin3 		= A2;
const int servopin3 		= 6;
// Desvio 4
const int divergent_led4 	= 9;
const int straight_led4		= 7;
const int buttonpin4 		= A3;
const int servopin4 		= 8;

// retard de pas del moviment del servo, en mil·lisegons
const int step_delay = 70;

// crear un objecte servo
Servo myservo1;
Servo myservo2;
Servo myservo3;
Servo myservo4;

// variables globals per emmagatzemar la posició del servo
int pos1 = straight1; // actual
int old_pos1 = pos1; // previa
int pos2 = straight2; // actual
int old_pos2 = pos2; // previa
int pos3 = straight3; // actual
int old_pos3 = pos3; // previa
int pos4 = straight; // actual
int old_pos4 = pos4; // previa


void setup()
{
//Desvio1  // estableix el mode dels pins digitals que s'utilitzen
  pinMode(buttonpin1, INPUT);
  pinMode(straight_led1, OUTPUT);
  pinMode(divergent_led1, OUTPUT);
//Desvio2  // estableix el mode dels pins digitals que s'utilitzen
  pinMode(buttonpin2, INPUT);
  pinMode(straight_led2, OUTPUT);
  pinMode(divergent_led2, OUTPUT);
//Desvio3  // estableix el mode dels pins digitals que s'utilitzen
  pinMode(buttonpin3, INPUT);
  pinMode(straight_led3, OUTPUT);
  pinMode(divergent_led3, OUTPUT);
//Desvio4  // estableix el mode dels pins digitals que s'utilitzen
  pinMode(buttonpin4, INPUT);
  pinMode(straight_led4, OUTPUT);
  pinMode(divergent_led4, OUTPUT);


  //Desvio 1  // configurar el servo
  myservo1.attach(servopin1);  // conectar el servo al pin 3
  myservo1.write(pos1); // posició inicial del servo
  //Desvio 2
  myservo2.attach(servopin2);  // conectar el servo al pin 3
  myservo2.write(pos2); // posició inicial del servo
  //Desvio 3  // configurar el servo
  myservo3.attach(servopin3);  // conectar el servo al pin 3
  myservo3.write(pos3); // posició inicial del servo
  //Desvio 4
  myservo4.attach(servopin4);  // conectar el servo al pin 3
  myservo4.write(pos4); // posició inicial del servo


  //Desvio 1  // estableix el estat inicial dels led
  digitalWrite(straight_led1, HIGH);
  digitalWrite(divergent_led1, LOW);
  //Desvio 2  // estableix el estat inicial dels led
  digitalWrite(straight_led2, HIGH);
  digitalWrite(divergent_led2, LOW);
  //Desvio 3  // estableix el estat inicial dels led
  digitalWrite(straight_led3, HIGH);
  digitalWrite(divergent_led3, LOW);
  //Desvio 4  // estableix el estat inicial dels led
  digitalWrite(straight_led4, HIGH);
  digitalWrite(divergent_led4, LOW);

}

void loop()
{
  // inicieu cada iteració del bucle llegint el botó
  // si es prem el botó (es llegeix ALT), mou el servo
  ////Desvio 1///
  int button_state1 = digitalRead(buttonpin1);
  if (button_state1 == HIGH) {
    // apagueu el led encès
    if (pos1 == straight1) {
      digitalWrite(straight_led1, LOW);
    } else {
      digitalWrite(divergent_led1, LOW);
    }
    old_pos1 = pos1;   // desar la posició actual

    // Alternar la posició al valor oposat
    pos1 = pos1 == straight1 ? divergent1 : straight1;

    // Mou el servo a la seva nova posició
    if (old_pos1 < pos1) { // si el nou angle és més gran
      // augmenta la posició del servo de old_pos to pos
      for (int i = old_pos1 + 1; i <= pos1; i++) {
        myservo1.write(i); // escriu la posició següent al servo
        delay(step_delay); // espera
      }
    } else {  // en cas contrari, el nou angle és igual o inferior
      // disminueix la posició del servo de oldpos a pos
      for (int i = old_pos1 - 1; i >= pos1; i--) {
        myservo1.write(i); // escriu la següent posició al servo
        delay(step_delay); // espera
      }
    }
    // encén el LED adequat.
    if (pos1 == straight1) {
      digitalWrite(straight_led1, HIGH);
    } else {
      digitalWrite(divergent_led1, HIGH);
    }

  }
  ////Desvio 2///
  int button_state2 = digitalRead(buttonpin2);
  if (button_state2 == HIGH) {
    // apagueu el led encès
    if (pos2 == straight2) {
      digitalWrite(straight_led2, LOW);
    } else {
      digitalWrite(divergent_led2, LOW);
    }
    old_pos2 = pos2;   // desar la posició actual

    // Alternar la posició al valor oposat
    pos2 = pos2 == straight2 ? divergent2 : straight2;

    // Mou el servo a la seva nova posició
    if (old_pos2 < pos2) { // si el nou angle és més gran
      // augmenta la posició del servo de oldpos to pos
      for (int i = old_pos2 + 1; i <= pos2; i++) {
        myservo2.write(i); // escriu la posició següent al servo
        delay(step_delay); // espera
      }
    } else {  // en cas contrari, el nou angle és igual o inferior
      // disminueix la posició del servo de oldpos a pos
      for (int i = old_pos2 - 1; i >= pos2; i--) {
        myservo2.write(i); // escriu la següent posició al servo
        delay(step_delay); // espera
      }
    }
    // encén el LED adequat.
    if (pos2 == straight2) {
      digitalWrite(straight_led2, HIGH);
    } else {
      digitalWrite(divergent_led2, HIGH);
    }

  }

  ////Desvio 3///
  int button_state3 = digitalRead(buttonpin3);
  if (button_state3 == HIGH) {
    // apagueu el led encès
    if (pos3 == straight3) {
      digitalWrite(straight_led3, LOW);
    } else {
      digitalWrite(divergent_led3, LOW);
    }
    old_pos3 = pos3;   // desar la posició actual

    // Alternar la posició al valor oposat
    pos3 = pos3 == straight3 ? divergent3 : straight3;

    // Mou el servo a la seva nova posició
    if (old_pos3 < pos3) { // si el nou angle és més gran
      // augmenta la posició del servo de oldpos to pos
      for (int i = old_pos3 + 1; i <= pos3; i++) {
        myservo3.write(i); // escriu la posició següent al servo
        delay(step_delay); // espera
      }
    } else {  // en cas contrari, el nou angle és igual o inferior
      // disminueix la posició del servo de oldpos a pos
      for (int i = old_pos3 - 1; i >= pos3; i--) {
        myservo3.write(i); // escriu la següent posició al servo
        delay(step_delay); // espera
      }
    }
    // encén el LED adequat.
    if (pos3 == straight3) {
      digitalWrite(straight_led3, HIGH);
    } else {
      digitalWrite(divergent_led3, HIGH);
    }
  ////Desvio 4///
  int button_state4 = digitalRead(buttonpin4);
  if (button_state4 == HIGH) {
    // apagueu el led encès
    if (pos4 == straight) {
      digitalWrite(straight_led4, LOW);
    } else {
      digitalWrite(divergent_led4, LOW);
    }
    old_pos4 = pos4;   // desar la posició actual

    // Alternar la posició al valor oposat
    pos4 = pos4 == straight ? divergent : straight;

    // Mou el servo a la seva nova posició
    if (old_pos4 < pos4) { // si el nou angle és més gran
      // augmenta la posició del servo de old_pos to pos4
      for (int i = old_pos4 + 1; i <= pos4; i++) {
        myservo4.write(i); // escriu la posició següent al servo
        delay(step_delay); // espera
      }
    } else {  // en cas contrari, el nou angle és igual o inferior
      // disminueix la posició del servo de oldpos a pos4
      for (int i = old_pos4 - 1; i >= pos4; i--) {
        myservo4.write(i); // escriu la següent posició al servo
        delay(step_delay); // espera
      }
    }
    // encén el LED adequat.
    if (pos4 == straight) {
      digitalWrite(straight_led4, HIGH);
    } else {
      digitalWrite(divergent_led4, HIGH);
    }

  }
  }
}
// final del bucle

Haré los cambios y luego lo posteo.

Esta es la versión que usa una estructura.
Como verás la estructura permite juntar todas las variables diferntes en algo común.
La defines como se te da la gana y luego simplemente creas un vector de ese nuevo tipo de variable si me permites.
Lo mismo hice con el objeto servo, en lugar de crear 4 distintos creo un vector de objetos de manera que con un índice [i] pueda relacionarme facilmente.
Luego todo lo pongo en un loop donde scannero de 0 a 3 o sea los 4 servos haciendo lo que tu hiciste 4 veces solo una vez.
Luce mas complicado pero si lo miras con NUEVOS OJOS verás que es mas simple y admite menos errores.
Si tienes que corregir algo, corriges para 1 y será para todos.

Verifica como se comporta.

#include <Servo.h>

// variables constants que s'utilitzen per establir angles de servo, en graus

struct Dispo {
  const int straight;
  const int divergent;
  const byte divergent_led;
  const byte straight_led;
  const byte buttonpin;
  const byte servopin;
  int pos;
  int old_pos;
  bool button_state;
  bool button_state_Ant;
};

Dispo dispo[4] = {
  {90, 120,  1,  0, A0, 3, 0, 0, false, false},
  {90, 120,  4,  2, A1, 5, 0, 0, false, false},
  {90, 120, 11, 10, A2, 6, 0, 0, false, false},
  {90, 120,  9,  7, A3, 8, 0, 0, false, false}
};


// retard de pas del moviment del servo, en mil·lisegons
const int step_delay = 70;

// crear un objecte servo
Servo myservo[4];

void setup() {
  // variables globals per emmagatzemar la posició del servo
  for (int i = 0; i < 4; i++) {
    dispo[i].pos = dispo[i].straight;
    dispo[i].old_pos = dispo[i].pos;
    pinMode(dispo[i].buttonpin, INPUT);
    pinMode(dispo[i].straight_led, OUTPUT);
    pinMode(dispo[i].divergent_led, OUTPUT);
    //Desvio configurar el servo
    myservo[i].attach(dispo[i].servopin);   // conectar el servo al pin X
    myservo[i].write(dispo[i].pos);     // posicion inicial del servo
    //Desvio 1  // estableix el estat inicial dels led
    digitalWrite(dispo[i].straight_led, HIGH);
    digitalWrite(dispo[i].divergent_led, LOW);
  }
}

void loop() {
  // Inicio caa iteracción del bucleo cuando se presiona el botón
  // si esta presionado muevo el servo
  //// Desvio ///

  for (int i = 0; i < 4; i++) {
    dispo[i].button_state = digitalRead(dispo[i].buttonpin);
    if (dispo[i].button_state == HIGH) {
      // apago el led
      if (dispo[i].pos == dispo[i].straight)
        digitalWrite(dispo[i].straight_led, LOW);
      else
        digitalWrite(dispo[i].divergent_led, LOW);
      dispo[i].old_pos = dispo[i].pos;   // actualizo la posición en curso
      // Alternar la posición al valor opuesto
      dispo[i].pos = dispo[i].pos == dispo[i].straight ? dispo[i].divergent : dispo[i].straight;

      // Muevo el servo a la nueva posición
      if (dispo[i].old_pos < dispo[i].pos) { // si el nou angle és més gran
        // aumenta la posición del servo de old_pos a pos
        for (int j = dispo[i].old_pos + 1; j <= dispo[i].pos; j++) {
          myservo[i].write(j); // escriu la posició següent al servo
          delay(step_delay); // espera
        }
      } else {  // en caso contrario, el nuevo angúlo sera igual o inferior
        // disminuyo la posición del servo de oldpos a pos
        for (int j = dispo[i].old_pos - 1; j >= dispo[i].pos; j--) {
          myservo[i].write(j); // escriu la següent posició al servo
          delay(step_delay); // espera
        }
      }
      // encender el led adecuado
      if (dispo[i].pos == dispo[i].straight)
        digitalWrite(dispo[i].straight_led, HIGH);
      else
        digitalWrite(dispo[i].divergent_led, HIGH);
    } // end if
  } // final del bucle
}

Buenas¡¡¡ Muchas Gracias por tu atención, como bien dices tengo que mirarlo con nuevos ojos, ahora queda mucho mas ordenado, tengo que releerlo, estudiarlo y comprenderlo desde otro punto de vista. entre hoy y mañana lo pruebo y te comento.
Atentamente, Mario

Se que te tiré por la cabeza algo que parece dificil de digerir.

Empieza por lo básico
si tu tienes 4 variables que llamas

int sensor1, sensor2, sensor3, sensor4:

es lo mismo que definir un vector o sea algo que guarda lo mismo pero que para consultarlo requiero de un indice.

int sensor[4];

para almacenar un dato lo hago asi

si fuera tu sensor1 le asignas asi

sensor1 = 4;

ahora sensor1 es sensor[0].
Porque empieza en 0 y no en 1... bueno, lo siento las listas comienzas en 0 y no en 1, hacerlo en 1 es desperdiciar el espacio anterior.

ese mismo dato 4 como se almacena en el vector? pues simple, infocas la posición 0 y lo guardas de este modo

sensor[0] = 4;

Ahora bien, ya que se entiende como se hace esto, ahora expandamos la imaginación y inventemos una estructura diferente. Algo que permita guardar tipos de variable diferente como si fuera el registro de una base de datos.

struct Dispo {
  const int straight;
  const int divergent;
  const byte divergent_led;
  const byte straight_led;
  const byte buttonpin;
  const byte servopin;
  int pos;
  int old_pos;
  bool button_state;
  bool button_state_Ant;
};

Metí todo en una structura, los pines, los botones, la posicion del servo, la posición anterior, el estado del boton y su valor anterior.
Y esto es lo potente de la estructura.

La estructura comienza con la palabra reservada

struct Nombre {
    // tipo de variables nombre
}

Como observarás, tolera constantes, y variables, incluso tambien tolera vectores.
Es muy potente y flexible.

Espero esto ayuda pero de lo contrario busca en google Arduino struct o en español y tendras mas y mejor información.

Buenas¡¡¡ Otra vez Gracias¡ por tu atención, he probado el scketch y funciona, ahora toca dedicar tiempo en aprender y seguir ampliando conocimientos. Ya se que me repito, pero Gracias por tu clase magistral.

Atentamente Mario

Pregunta lo que sea que te genere dudas.