Errores al compilar, no encuentro el problema del codigo

Buenas.
Soy novato y estoy intentando hacer algun proyecto sencillo, pero hay que ver como lo sencillo a veces se complica.
Os dejo al final del mensaje los errores que me da al compilar.
Os pongo el codigo, a ver si veis donde puede estar el problema:

/*Programa subir parar bajar persiana con dos pulsadores.
Si mantenemos el boton presionado menos de 2 segundos, subira o
bajara hasta que soltemos el pulsador, si pulsamos más de dos
segundos, subira o bajara hasta el final de carrera o pulso del
pulsador contrario.
*/

const int FCarriba = 2; // Final de carrera superior en pin 2
const int FCabajo = 3; //Final de carrera inferior en pin 3
const int SWarriba = 4; //Pulsador para subir en pin 4
const int SWabajo = 5; //Pulsador para bajar en pin 5
const int arriba = 6; //rele de subir en pin 6
const int abajo = 7; //rele de bajar en pin 7
const int antirrebote = 10; //Tiempo para evitar rebote
const int tiempoAuto = 2000; //tiempo en ms para que pase automatico
int estadoSWabajo; //Estado del pulsador de bajada
int estadoAnteriorSWabajo; //Estado anterior del pulsador de bajada
int estadoSWarriba; //Estado del pulsador de subida
int estdoAnteriorSWarriba; //Estado anteior del pulsador de subida

boolean antirrebote(int pin) { //funcion antirrebote
  int contador = 0; //variable contador y la ponemos a 0
  boolean estado; //variable estado
  boolean estadoAnterior; //variable estado anterior

  do {
    estado = digitalRead(pin); //Leemos y ponemos al esto del pulsador
    if(estado != estadoAnterior){ // Si el estado acual y al anteior no son iguales
      contador = 0; //Ponemos el contador a 0
      estadoAnterior = estado; //Igualamos el estado anterior y el actual
    }
    else {
      contador = contador + 1; //Sumanos uno al contador
    }
    delay(1);  //Esperamos 1 ms
  }
  while (contadorAuto < tiempoAuto); //Permanecemos en el bucle mientras contador sea menor que tiempoauto
  
  return estado; //Devuelve estado
}

boolean auto(int pinAuto) { //Funcion movimiento automatico
  int contadorAuto = 0;
  boolean estadoAuto;
  boolean estadoAutoAnterior;

  do {
    estadoAuto = digitalRead(pinAuto); //Leemos y ponemos al estado del pulsador
    if(estadoAuto != estadoAutoAnterior){ // Si el estado acual y al anteior no son iguales
      contadorAuto = 0; //Ponemos el contador a 0
      estadoAutoAnterior = estadoAuto; //Igualamos el estado anterior y el actual
    }
    else {
      contadorAuto = contadorAuto + 1; //Sumanos uno al contador
    }
    delay(1);  //Esperamos 1 ms
  }
  while (contadorAuto < tiempoAuto); //Permanecemos en el bucle mientras contador sea menor que tiempoauto
  
  return estadoAuto; //Devuelve estado
}

void setup()   {
  pinMode (FCarriba, INPUT);
  pinMode (FCabajo, INPUT);
  pinMode (SWarriba, INPUT);
  pinMode (SWabajo, INPUT);
  pinMode (arriba, OUTPUT);
  pinMode (abajo, OUTPUT);
  
}

void loop() {
  //Declaramos la seguridad y finales de carrera
  if (arriba == HIGH) digitalWrite(abajo, LOW);//si esta subiendo, bajar esta desactivado
  if (abajo == HIGH) digitalWrite(arriba, LOW);//si esta bajando, subir esta desactivado
  if (FCarriba == HIGH) digitalWrite(arriba, LOW);
  if (FCabajo == HIGH) digitalWrite(abajo, LOW);
  if (SWarriba == HIGH) digitalWrite(abajo, LOW);
  if (SWabajo == HIGH) digitalWrite (arriba, LOW);
  
  //Si mantenemos los puldores al mismo tiempo, pone a LOW las salidas
  if (SWarriba == SWabajo){
    digitalWrite(abajo, LOW);
    digitalWrite(arriba, LOW);
  }
  
  //si pulsamos arriba
  estadoSWarriba = digitalRead(SWarriba)
  if(estadoSWarriba != estadoAnteiorSWarriba){
    digitalWrite(abajo, LOW);
    if(antirrebote(SWarriba)) digitalWrite(arriba, HIGH);//antirrebote y subimos
    else{
      digitalWrite(arriba, LOW);//si soltamos subir, para
    }
    if(auto(SWarriba)){//si pulsamos más de X tiempo
        digitalWrite(arriba, HIGH)//sube automaticamente
        if(SWabajo == HIGH) digitalWrite(arriba, LOW)//si pulsamos bajar, para
    }
  }
  
  estadoSWabajo = digitalRead(SWabajo)
  if(estadoSWabajo != estadoAnteiorSWabajo){
    digitalWrite(arriba, LOW);
    if(antirrebote(SWabajo)) digitalWrite(abajo, HIGH);
    else{
      digitalWrite(abajo, LOW);
    }
    if(auto(SWabajo)){
        digitalWrite(abajo, HIGH)
        if(SWarriba == HIGH) digitalWrite(abajo, LOW)
    }
  }
  
  //Declaramos la seguridad y finales de carrera
  if (arriba == HIGH) digitalWrite(abajo, LOW);//si esta subiendo, bajar esta desactivado
  if (abajo == HIGH) digitalWrite(arriba, LOW);//si esta bajando, subir esta desactivado
  if (FCarriba == HIGH) digitalWrite(arriba, LOW);
  if (FCabajo == HIGH) digitalWrite(abajo, LOW);
  if (SWarriba == HIGH) digitalWrite(abajo, LOW);
  if (SWabajo == HIGH) digitalWrite (arriba, LOW);
  
  //Si mantenemos los puldores al mismo tiempo, pone a LOW las salidas
  if (SWarriba == SWabajo){
    digitalWrite(abajo, LOW);
    digitalWrite(arriba, LOW);
  }

Errores:

Motor_persiana:9: error: expected unqualified-id before 'int'
Motor_persiana:9: error: expected `)' before 'int'
Motor_persiana:13: error: 'const int antirrebote' redeclared as different kind of symbol
Motor_persiana:8: error: previous declaration of 'boolean antirrebote(int)'
Motor_persiana.ino: In function 'boolean antirrebote(int)':
Motor_persiana:36: error: 'contadorAuto' was not declared in this scope
Motor_persiana.ino: At global scope:
Motor_persiana:41: error: expected unqualified-id before 'int'
Motor_persiana:41: error: expected `)' before 'int'

Todos no te los voy a poder aclarar, mis conocimientos son demasiado escasos, pero parte si:

defines dos veces "antirebote"
...
const int antirrebote = 10; //Tiempo para evitar rebote
const int tiempoAuto = 2000; //tiempo en ms para que pase automatico
int estadoSWabajo; //Estado del pulsador de bajada
int estadoAnteriorSWabajo; //Estado anterior del pulsador de bajada
int estadoSWarriba; //Estado del pulsador de subida
int estdoAnteriorSWarriba; //Estado anteior del pulsador de subida

boolean antirrebote(int pin) { //funcion antirrebote
...

en la funcion "antirrebote", falta de definir la vaiable "contadorAuto"

boolean antirrebote(int pin) { //funcion antirrebote
...
while (contadorAuto < tiempoAuto); //Permanecemos en el bucle mientras contador sea menor que tiempoauto

y una cosa que no tengo claro es que se pueda usar esto:

const int SWabajo = 5; //Pulsador para bajar en pin 5
...
if (SWabajo == HIGH) digitalWrite (arriba, LOW);

si la defines como constante, para que compruebas su valor?

Un saludo

Te aconsejo postear usando los tags de "code", ya que es mucho más claro poder entender el código y no ocupa media página.

Visto por encima antes de profundizar, estás usando variables con el mismo nombre que funciones. Cambia esto primero y vuelve a compilar, posteando usando el tag de "code" tanto el código como los errores.

Saludos

mira si te puede servir algo asi:

/*Programa subir parar bajar persiana con dos pulsadores.
Si mantenemos el boton presionado menos de 2 segundos, subira o
bajara hasta que soltemos el pulsador, si pulsamos más de dos 
segundos, subira o bajara hasta el final de carrera o pulso del
pulsador contrario.
*/
byte Input[4]={2,3,4,5};                       // Pines de entrada de FCarriba, FCabajo, SWarriba, SWabajo
byte Output[2]={6,7};                          // Pines de salida de RLarriba, RLabajo

boolean FCarriba, FCabajo, SWarriba, SWabajo;  // Estado de las entradas
boolean RLarriba, RLabajo;                     // Estado de las salidas (reles)

unsigned long tiempoAuto=2000;                 // tiempo en ms para que pase automatico
unsigned long tiempoPulsado=0;                 // Para conocer cuanto tiempo lleva pulsado cualquiera de lso dos pulsadores
unsigned long EsperaSubir=0;                   // Para conocer cuanto tiempo tiene que esperar antes de poder subir 
unsigned long EsperaBajar=0;                   // Para conocer cuanto tiempo tiene que esperar antes de poder bajar 
unsigned long EsperaManiobras=500;             // tiempo a esperar antes de invertir giro del motor

boolean SubiendoAutomatico=false;
boolean BajandoAutomatico=false;

void setup()   
{
  for (int x=0;x<4;x++){pinMode (x, INPUT);}
  for (int x=0;x++;x<2)
  {
    pinMode (x, OUTPUT);
    digitalWrite (x,LOW);
  }
  RLarriba=RLabajo=false;
}

void loop() 
{
  LeerEntradas();
  if (SubiendoAutomatico)                      // Esta haciendo la maniobra de subir automatica
  {
    if (FCarriba || SWabajo)                   // Si llega a fcarriba o pulsamos bajar, finaliza maniobra
    {
      RLarriba=false;                          // Apagar rele subir
      EsperaBajar=millis()+EsperaManiobras;    // Almacenamos el tiempo necesario para poder invertir el giro
      SubiendoAutomatico=false;                // Fin maniobra
    }
  }
  else if (BajandoAutomatico)                  // Esta haciendo la maniobra de subir automatica
    {
      if (FCabajo || SWarriba)                 // Si llega a fcabajo o pulsamos subir, finaliza maniobra
      {
        RLabajo=false;                         // Apagar rele subir
        EsperaSubir=millis()+EsperaManiobras;  // Almacenamos el tiempo necesario para poder invertir el giro
        BajandoAutomatico=false;               // Fin maniobra
      }
    }
    else {GestionPulsadores();}                // No esta relizando ninguna maniobra, atender pulsadores
  GrabarSalidas();
}

void LeerEntradas() 
{
  FCarriba=digitalRead(Input[0]);
  FCabajo =digitalRead(Input[1]);
  SWarriba=digitalRead(Input[2]);
  SWabajo =digitalRead(Input[3]);  
}

void GrabarSalidas() 
{
  digitalWrite(Output[0],RLarriba);
  digitalWrite(Output[1],RLabajo);  
}

void GestionPulsadores()
{
  if (SWarriba && !FCarriba && !SWabajo && !RLabajo)  // si Pulsamos subir y no esta ya arriba y no pulsamos bajar y no esta bajando
  {
    if (!RLarriba)                                    // Si el rele no esta activo, es que pulsamos subir por primera vez
      {tiempoPulsado=millis() + tiempoAuto;}          // Almacenamos cuanto tiempo ha de pasar para arrancar en automatico 
    if (RLarriba && millis() >tiempoPulsado)          // Si estamos subiendo y ha pulsado mas tiempo de tiempoauto el pulsador, arancamos automatico
      {SubiendoAutomatico=true;}                      // Asi no vuelve a entrar a gestion pulsadores, solo tenemos que controlar el fin de la maniobra   
    if (millis()>EsperaSubir)                         // Si ha transcurrido el tiempo a esperar antes de invertir giro
    {
      RLarriba=true;                                  // Activar rele subir
      EsperaBajar=millis()+EsperaManiobras;           // Almacenamos el tiempo necesario para poder invertir el giro               
    }
    RLabajo=false;                                    // Desactivar rele bajar
  }
   
  if (SWabajo && !FCabajo && !SWarriba && !RLarriba)  // Si pulsamos bajar y no esta ya abajo y no pulsamos subir y no esta subiendo, igual que el if anterior pero con bajar
  {
    if (!RLabajo) {tiempoPulsado=millis();}
    if (RLabajo && millis() > (tiempoPulsado + tiempoAuto)) {BajandoAutomatico=true;}
    if (millis()>EsperaBajar)                               
    {
      RLabajo=true;                                        
      EsperaSubir=millis()+EsperaManiobras;                                
    }
    RLarriba=false;  
  }
}

Gracias Agju por la recomendacion del uso de "code", lo estuve intentando con "spoiler", pero claro, no todos los foros son iguales.
Marcial, gracias por tu version del codigo, estoy estudiandolo, a ver si entiendo lo que significa.
De todos modos voy a revisar mi codigo a ver si veo las repeticiones que comentas.

No acabo de entender que significa esto:

void setup()
{
for (int x=0;x<4;x++){pinMode (x, INPUT);}
for (int x=0;x++;x<2)
{
pinMode (x, OUTPUT);
digitalWrite (x,LOW);
}

Alguien me arroje algo de luz?

Gracias por todas las respuestas.

Echa un vistazo en la referencia a la instrucción for, y deducirás que el primer for establece los pines 0 a 3 como INPUT.
El segundo for, aunque el compilador no te va a dar error tiene pinta de que en lugar de for (int x=0;x++;x<2) debería ser for (int x=0;x<2;x++), y lo que haría es establecer los pines 0 a 2 como OUTPUT y los pone en LOW.
Como no parece tener mucha lógica, supongo que lo que realmente quería el compañero era lo siguiente:

  for (int x=0;x<4;x++){pinMode (Input[x], INPUT);}
  for (int x=0;x<2;x++)
  {
    pinMode (Output[x], OUTPUT);
    digitalWrite (Output[x], LOW);
  }

Que hará lo propio con los cuatro pines declarados en el array Output y los dos declarados en el array Input.

Pero, qué sentido tiene cambiar continuamente la variable "x" de "INPUT" a "OUTPUT", seguro que es logico, pero no lo entiendo.

for (int x=0;x<4;x++){pinMode (Input[x], INPUT);}
  for (int x=0;x<2;x++)
  {
    pinMode (Output[x], OUTPUT);
    digitalWrite (Output[x], LOW);
  }

Y otra cosa que no acabo de ver es por qué se crean variables en "LOOP" y no al comienzo del Sketch.

Te explico el primer for, y entenderás los dos.

byte Input[4]={2,3,4,5};                       // Pines de entrada de FCarriba, FCabajo, SWarriba, SWabajo
for (int x=0;x<4;x++){pinMode (Input[x], INPUT);}

La primera declaración establece un array de cuatro elementos:
Input[0]=2
Input[1]=3
Input[2]=4
Input[3]=5

El for va a recorrer x desde 0 hasta 3 (cuando valga 4 saldrá del bucle).
x=0, Input[x]=Input[0]=2, establece como entrada el pin 2
x=1, Input[x]=Input[1]=3, establece como entrada el pin 3
x=2, Input[x]=Input[2]=4, establece como entrada el pin 4
x=3, Input[x]=Input[3]=5, establece como entrada el pin 5

El declarar la variable en el bucle crea una variable que se "olvida" al salir del mismo, y que no interfiere externamente. Por ejemplo, el código

int x=326;
for(x=0;x<5;x++) {Serial.println(x);} //Aquí la x que vale es la del for
Serial.print(x); //Aquí la x que vale es la de fuera del for

Nos dará la salida
0
1
2
3
4
326

Gracias noter por la explicacion, más o menos lo entendi, a ver si poco a poco voy entendiendo porque se hacen este tipo de cosas, en otros sketch y documentación.
No podreis apuntarme donde encontrar documentacion extendida.

Muchas gracias

noter : Yo no lo hubiera explicado mejor.

Cold: disculpa el horror,

No te preocupes Marcial.
Os agradezco mucho las molestias que os habeis tomado. A ver si me hacerco por el FAB LAB LEON, a ver si hago algun ejercicio con las nuevas ordenes que me habeis descubierto.

Un saludo.