Chiamata funzioni esterne

Ancora nello sviluppo del mio cambio automatico.
Giunto alla necessità di utilizzare una funzione esterna alla void loop (), e nulla da fare, ho dichiarato la funzione nello stesso sketch della loop e della setup, alla fine della loop.
Ma quando l’ide arriva a compilare nel punto in cui la tale funzione viene chiamata, restituisce l’errore ‘funzione’ was not declared in this scope

incollo il codice…

// Include Libraries
#include "Arduino.h"
#include "Button.h"
#include "Potentiometer.h"
//#include "StepperMotor.h"
#include <AccelStepper.h>
#include <MultiStepper.h>
#include <Bounce2.h>

// Pin Definitions
#define NEMA_1_DIREZIONE 2
#define NEMA_1_PASSO 3
#define NEMA_2_DIREZIONE 4
#define NEMA_2_PASSO 5
#define SLIDESWITCH 6
#define HALL_1 7
#define HALL_2 8
#define MICROSWITCH_1 9
#define MICROSWITCH_2 10
#define POTENZIOMETRO_1 A6
#define POTENZIOMETRO_2 A7
const int numStepMotore = 200; //E' il numero di step per rotazione del motore (potrebbe differire in base al modello)
const long velocita = 1000; //Si tratta di microsecondi tra un impulso e l'altro sul pin STEP

// Global variables and defines
#define stepper_1DelayTime  1000
#define stepper_2DelayTime  1000
// object initialization

AccelStepper nem_1(AccelStepper::DRIVER, NEMA_1_PASSO, NEMA_1_DIREZIONE); //0.8A/1.25A-2.3V/4.6V 800mA  -6.6ohm 0.76A 5V-
AccelStepper nem_2(AccelStepper::DRIVER, NEMA_2_PASSO, NEMA_2_DIREZIONE); //0.8A/1.25A-2.3V/4.6V 800mA  -6.4ohm 0.78A 5V-
Button hal_1(HALL_1); //3,5-24V 50mAh 0.5mA*2 -10001ohm 0,5mah 5v-
Button hal_2(HALL_2); //3,5-24V 50mAh 0.5mA*2 -10001ohm 0,5mah 5v-
Button end_1(MICROSWITCH_1); //5V/0,1mA-12V/2A 0,5mA*2 -10001ohm 0,5mah 5v-
Button end_2(MICROSWITCH_2); //5V/0,1mA-12V/2A 0,5mA*2 -10001ohm 0,5mah 5v-
Potentiometer pot_1(POTENZIOMETRO_1); //3.3-5V 5v=0.5mA*2 -10001ohm 0,5mah 5v-
Potentiometer pot_2(POTENZIOMETRO_2); //3.3-5V 5v=0.5mA*2 -10001ohm 0,5mah 5v-
Button swi_1(SLIDESWITCH); //0.1V-24V 5v=0,5mA -10001ohm 0,5mah 5v-

//corrente necessaria

// define vars for testing menu
int velo = 1000;
const int debounceMs = 10;

const int mar_set[14][2]{
  {1,1},
  {1,2},
  {1,3},
  {1,4},
  {1,5},
  {2,3},
  {2,4},
  {2,5},
  {2,6},
  {2,7},
  {3,6},
  {3,7},
  {3,8},
  {3,9},
};
bool hal_a, hal_b, end_a=0, end_b=0, swi_a;
bool pos_a, pos_b;
int cor_inn, cor_ins, rap_inn, rap_ins, mar_inn[3], mar_ins[3], swi;
int tempo1, tempo2, tempo3, diff1, diff2, diff3;
byte data;
float vel, val;

// Setup the essentials for your circuit to work. It runs first every time your circuit is powered with electricity.
void setup()
{
  // Setup Serial which is useful for debugging
  // Use the Serial Monitor to view printed messages
  Serial.begin(9600);
  while (!Serial) ; // wait for serial port to connect. Needed for native USB
  Serial.println("start");

  //inizializzo i PIN come OUTPUT

  nem_1.setMaxSpeed(velo);
  nem_2.setMaxSpeed(velo);
  hal_1.init();
  hal_2.init();
  end_1.init();
  end_2.init();
  swi_1.init();

  pinMode(NEMA_1_DIREZIONE, OUTPUT);
  pinMode(NEMA_1_PASSO, OUTPUT);
  pinMode(NEMA_2_DIREZIONE, OUTPUT);
  pinMode(NEMA_2_PASSO, OUTPUT);

}

// Main logic of your circuit. It defines the interaction between the components you selected. After setup, it runs over and over again, in an eternal loop.
void loop()
{

  // Slide Pot - X-Large (10k Linear Taper) #2 - Test Code
  int pot_a = pot_1.read();
  int pot_b = pot_2.read();
  Serial.print(F("il potenziometro a comunica il valore: ")); Serial.println(pot_a);
  Serial.print(F("il potenziometro b comunica il valore: ")); Serial.println(pot_b);
  //capire come usare potenziometri
  //impostare lettura potenziometri
  cor_inn=pot_a/73; //temporaneo
  rap_inn=pot_b/341; //temporaneo
  Serial.print(F("La corona innestata è la ")); Serial.println(cor_inn);    // scrivo il valore sulla seriale come debugging
  Serial.print(F("Il rapporto innestato è il ")); Serial.println(rap_inn); 
  //tradurre lettura potenziometri in posizione corona e rapporto
  //tradurre corona e rapporto in mar_inn
  mar_inn[1] = cor_inn;
  mar_inn[2] = rap_inn;
  Serial.println(mar_inn[2],mar_inn[1]); // scrivo il valore sulla seriale come debugging
  switch (mar_inn[1])
  {
    case 1: switch (mar_inn[2])
      {
        case 1:
          mar_inn[0] = 1;
          break;
        case 2:
          mar_inn[0] = 2;
          break;
        case 3:
          mar_inn[0] = 3;
          break;
        case 4:
          mar_inn[0] = 4;
          break;
        case 5:
          mar_inn[0] = 5;
          break;
      }
    case 2:
      switch (mar_inn[2])
      {
        case 3:
          mar_inn[0] = 6;
          break;
        case 4:
          mar_inn[0] = 7;
          break;
        case 5:
          mar_inn[0] = 8;
          break;
        case 6:
          mar_inn[0] = 9;
          break;
        case 7:
          mar_inn[0] = 10;
          break;
      }
    case 3:
      switch (mar_inn[2])
      {
        case 6:
          mar_inn[0] = 11;
          break;
        case 7:
          mar_inn[0] = 12;
          break;
        case 8:
          mar_inn[0] = 13;
          break;
        case 9:
          mar_inn[0] = 14;
          break;
      }
  }
  Serial.print(F("La marcia innestata è la ")); Serial.println(mar_inn[0]); 
  mar_ins[0] = mar_inn[0]; //eguaglia marcia da innestare con marcia innestata
  mar_ins[1] = mar_inn[1];
  mar_ins[2] = mar_inn[2];
  if (swi==0)
  {
    while(swi==0)
    {
      pos_a = pos_b = 0;
      pos_a = end_1.read();
      pos_b = end_2.read();
      if (pos_a != pos_b);
      {
        if (pos_a==1){
          mar_ins[0]++;
        }
        if (pos_b==1){
          mar_ins[0]--;
        }
        mar_ins[1] = mar_set[mar_ins[0]][1];
        mar_ins[2] = mar_set[mar_ins[0]][2];
      }
      while (pot_a =! mar_ins[1])
      {
        if (pot_a < mar_ins[1])
        {
          digitalWrite(NEMA_1_DIREZIONE, HIGH);
          if(check_fw(HALL_1)==1)
          {
            nem_1.run();
          }
        }
        if (pot_a > mar_ins[1])
        {
          digitalWrite(NEMA_1_DIREZIONE, LOW);
          if(check_fw(HALL_1)==1)
          {
            nem_1.run();
          }
        }
        if (pot_a == mar_ins[1])
        {
          nem_1.stop();
        }
      }
      while (pot_b =! mar_ins[2])
      {
        if (pot_b < mar_ins[2])
        {
          digitalWrite(NEMA_2_DIREZIONE, HIGH);
          nem_2.run();
        }
        if (pot_b > mar_ins[2])
        {
          digitalWrite(NEMA_2_DIREZIONE, LOW);
          nem_2.run();
        }
        if (pot_b == mar_ins[2])
        {
          nem_2.stop();
        }
      }
    }
    while(swi==1)
    {
      
    }
  }
  delay(5000);
  
  //nem_1=sposta in posizione mar_ins[1], a fine movimento controllare corretta posizione pot_a;
  //nem_2=sposta in posizione mar_ins[2], a fine movimento controllare corretta posizione pot_b;
  for(int i = 0; i < 3; ++i)
  {
    Serial.print(F("marcia/corona/rapporto innestati "));Serial.println(mar_ins[i]);
    if (i==2){break;};
  }
  Serial.println(" ");
  delay(5000);
  //  if (millis() - time0 > timeout)
}

int check_fw(HALL_1)
{
  int step0=millis();
  int step1;
  int step2;
  int stepOk;
  while(pin==LOW)
  {
    step1=millis();
    break;
  }
  delay(10);
  while(pin==LOW)
  {
    step2=millis();
  }
  step2=step2-step1;
  step1=step1-step0;
  if (step1>step2)
  {
    stepOk=1;
  }else{stepOk=0;};
  return (stepOk);
}

Mi ci sto scervellando da 2 giorni ma continuo a non capire la causa del problema.

ho provato a compilare il tutto ma con le librerie che ho trovato per potentiometer e button mi da un sacco di errori di metodi inesistenti come button.init, button.read e potentiometer.read
... evidentemente le tue sono diverse

ad ogni modo nella funzione
int check_fw(HALL_1)
manca la definizione del parametro (int, long...)

e siccome alla riga 17 hai messo
#define HALL_1 7
la funzione non ha senso e comunque non compila (devi cambiare il nome del parametro)
se la chiami
int check_fw(int pippo) {
compila :slight_smile:

inoltre il parametro hall_1 non viene mai usato...
mentre esegui un controllo su "pin" (riga 246) che non è mai definito

Molte grazie per le varie utili segnalazioni!

Provvedo a rettificare...

In ogni caso le funzioni devono essere definite PRIMA di essere utilizzate. O perlomeno ci vuole il loro prototipo. Arduino cerca di inserire quest'ultimo da solo, ma non sempre ci riesce.

Grazie a @Silente sono andato molto avanti nel programma.
Non si è sostituito a me, ma mi ha ben guidato.
Non so ancora se il firmware funzioni ma questo è il punto a cui sono giunto…

//inclusione librerie
#include "AccelStepper.h"
#include "MultiStepper.h"

//definizione dei pin: questo pezzo di codice serve a dare un nome ai pin per semplificare la stesura del programma, giusto?
const int pinNEMA[] = {2, 3, 4, 5}; /*array di pin dei driver dei motori passo-passo*/
const bool pinBUT[] = {6, 7, 8, 9, 10}; /*array di pin dedicati ai 2 sensori Hall, ai due pulsanti ed allo switch*/
const int pinPOT[] = {A6, A7}; /*array di pin analogici acui saranno connesse le uscite dei 2 potenziometri*/
const int rappow = 73; /*valore provvisorio, distanza sul potenziometro tra ogni rapporto*/
const int corpow = 341; /*valore provvisorio, distanza sul potenziometro tra ogni corona*/

AccelStepper nem_0 (AccelStepper::DRIVER, pinNEMA[0], pinNEMA[1]);
AccelStepper nem_1 (AccelStepper::DRIVER, pinNEMA[2], pinNEMA[3]);
bool input[5]; /*2 pulsanti, uno switch e 2 sensori a effetto Hall U1881*/
bool buttonState = LOW; /*serve per il debounce*/
int pressed=0; /*serve per il debounce*/
int pot[2] ; /*2 potenziometri*/
int marce[2]; /*[0]=marcia innestata [1]=marcia da innestare*/
int distance0; /*distanza tra la corona da innestare e quella innestata*/
int distance1;  /*distanza tra il rapporto da innestare e quello innestato*/
int velo = 1000; /*velocità massima di corsa dei motori passo-passo*/
float velocita;
const int debounceMs = 10; /*durata del debounce*/
const int mar_set[14][2] { /*l'array bidimensionale serve come maschera da cui ricavare la marcia in base alla corona/rapporto da innestare*/
  {1, 1}, /*marcia 1*/
  {1, 2}, /*marcia 2*/
  {1, 3}, /*marcia 3*/
  {1, 4}, /*marcia 4*/
  {1, 5}, /*marcia 5*/
  {2, 3}, /*marcia 6*/
  {2, 4}, /*marcia 7*/
  {2, 5}, /*marcia 8*/
  {2, 6}, /*marcia 9*/
  {2, 7}, /*marcia 10*/
  {3, 6}, /*marcia 11*/
  {3, 7}, /*marcia 12*/
  {3, 8}, /*marcia 13*/
  {3, 9}, /*marcia 14*/
};

void setup() {
  Serial.begin(9600);
  while (!Serial);
  Serial.println(F("start"));

  nem_0.setMaxSpeed(velo);  /*imposta la velocità massima del motore 0*/
  nem_1.setMaxSpeed(velo);  /*imposta la velocità massima del motore 1*/

  pinMode(pinNEMA[0], OUTPUT);  /*imposta come uscita il pin 2*/
  pinMode(pinNEMA[1], OUTPUT);  /*imposta come uscita il pin 3*/
  pinMode(pinNEMA[2], OUTPUT);  /*imposta come uscita il pin 4*/
  pinMode(pinNEMA[3], OUTPUT);  /*imposta come uscita il pin 5*/
  pinMode(pinBUT[0], INPUT);  /*imposta come ingresso il pin 6*/
  pinMode(pinBUT[1], INPUT);  /*imposta come ingresso il pin 7*/
  pinMode(pinBUT[2], INPUT);  /*imposta come ingresso il pin 8*/
  pinMode(pinBUT[3], INPUT);  /*imposta come ingresso il pin 9*/
  pinMode(pinBUT[4], INPUT); /*imposta come ingresso il pin 10*/
}

void loop() {
  // put your main code here, to run repeatedly:
  Serial.println(F("il potenziometro a comunica il valore: ")); 
  Serial.println(pot[0]);
  Serial.println(F("il potenziometro b comunica il valore: ")); 
  Serial.println(pot[1]);
  marce[1] = marce[0] = check_mar(); /*identifica marcia innestata usando la funzione check_mar() e le eguaglia marcia da innestare*/
  for (int i = 0; i < 2; i++)
  {
    Serial.println(marce[i]);  /*mostra marcia, corona e rapporto innestati e marcia da innestare.*/
    Serial.println(pot[i]);
  }
  while (digitalRead(pinBUT[4]) == LOW) /*imposta il cambio in modalità sequenziale*/
  {
    Serial.println(F("sequenziale"));
    if (debounceButton_2(buttonState) == HIGH && buttonState == LOW) /*funzione di debounce per l'azionamento del pulsante su*/
    {
      pressed++;  /*aumenta di 1 ogni volta che viene premuto il pulsante 2*/
      buttonState = HIGH; /*imposta a 1 il valore della variabile buttonState*/
      Serial.println(F("tasto su premuto"));
      if (marce[1] < 14) /*se la marcia è inferiore alla 14 viene aumentata di 1*/
      {
        marce[1]++; /*aumenta marcia da innestare di 1*/
      } else 
      {marce[1] = 14;} /*altrimenti imposta la marcia da innestare a 14*/
    }
    else if(debounceButton_2(buttonState) == LOW && buttonState == HIGH) /*funzione di debounce per l'azionamento del pulsante su*/
    {
      buttonState = LOW;  /*imposta a 0 il valore di buttonState*/
      Serial.println(F("tasto su rilasciato"));
    }
    if (debounceButton_3(buttonState) == HIGH && buttonState == LOW) /*funzione di debounce per l'azionamento del pulsante giù*/
    {
      pressed--;  /*diminuisce di 1 ogni volta che viene premuto il pulsante 3*/
      buttonState = HIGH; /*imposta a 1 il valore della variabile buttonState*/
      Serial.println(F("tasto giu' premuto"));
      if (marce[1] > 1) /*se la marcia è maggiore di uno, il valore di marcia da innestare viene di minuito di 1*/
      {
        marce[1]--; /*diminuisce di 1 il valore della marcia da innestare*/
      } else
      {marce[1] = 1;} /*altrimenti imposta ad 1 la marcia da innestare*/
    }
    else if(debounceButton_3(buttonState) == LOW && buttonState == HIGH) /*funzione di debounce per l'azionamento del pulsante su*/
    {
      buttonState = LOW;  /*imposta a 0 il valore di buttonState*/
    }
    if (marce[1] != marce[0]) /*controlla se la marcia da innestare è diversa da quella innestata e nel caso la innesta*/
    {
      int corrap = 0; /*variabile necessaria alla misura della distanza tra il rapporto/corona da innestare e quello innestato*/
      distance0 = calcdist(marce[corrap],corrap); /*chiama la funzione calcdist che calcola la distanza tra la corona innestata e quella da innestare */
      corrap = 1; 
      distance1 = calcdist(marce[corrap],corrap); /*chiama la funzione calcdist che calcola la distanza tra il rapporto innestato e quello da innestare */
      if(distance1!=0)
      {
        if (check_fw() == 1) /*controlla senso e rotazione pedali*/
        {
          nem_0.move(distance0); /*sposta il motore nella posizione indicata da distance0*/
          nem_1.move(distance1); /*sposta il motore nella posizione indicata da distance1*/
        }
      }
    }
  }
 while (digitalRead(pinBUT[4]) == HIGH) /*imposta il cambio in modalità automatica*/
  {
    velocita=velox(); 
    if (velocita>7,5)
    {
      marce[1]=scegliMarcia(velocita);
    }
  }
}

int scegliMarcia(float vel)
{
  if(vel>41,19){return(14);}
  if(vel>35,7) {return(13);}
  if(vel>31,5) {return(12);}
  if(vel>27,2) {return(11);}
  if(vel>24)   {return(10);}
  if(vel>20,4)  {return(9);}
  if(vel>17,74) {return(8);}
  if(vel>15,69) {return(7);}
  if(vel>14,03) {return(6);}
  if(vel>12,2)  {return(5);}
  if(vel>10,79) {return(4);}
  if(vel>9,35)  {return(3);}
  if(vel>8,25)  {return(2);}
  if(vel<=8,25) {return(1);}
}

int velox()
{
  unsigned long tempo1; /*prima variabile temporale: per controllo senso rotazione ruota*/
  unsigned long tempo2; /*seconda variabile temporale: per controllo senso rotazione ruota e per calcolo velocità*/
  unsigned long tempo3; /*terza variabile temporale: per controllo senso rotazione ruota*/
  unsigned long tempo4; /*quarta variabile temporale: per calcolo velocità*/
  int diff1, diff2, diff3;  /*variabili temporali, per controllo senso rotazione ruota e per calcolo velocità*/
  float velocita; /*variabile di ritorno alla loop con velocità*/
  while(digitalRead(pinBUT[1]) == HIGH){delay(2);} /*attende la disattivazione del sensore hall2*/
  while(digitalRead(pinBUT[1]) == LOW) /*inserisce il valore di millis nella variabile tempo1 finché il sensore hall2 non cambia stato a HIGH*/
  {
    tempo1 = millis;
  }
  while(digitalRead(pinBUT[1]) == HIGH) /*inserisce il valore di millis nella variabile tempo2 finché il sensore hall2 non cambia stato a LOW*/
  {
    tempo2 = millis;
  }
  while(digitalRead(pinBUT[1]) == LOW) /*inserisce il valore di millis nella variabile tempo3 finché il sensore hall2 non cambia stato a HIGH*/
  {
    tempo3 = millis;
  }
  while(digitalRead(pinBUT[1]) == HIGH) /*inserisce il valore di millis nella variabile tempo4 finché il sensore hall2 non cambia stato a LOW*/
  {
    tempo4 = millis;
  }
  diff1 = tempo3-tempo2; /*calcola la differenza tra tempo3 e tempo2*/
  diff2 = tempo2-tempo1; /*calcola la differenza tra tempo2 e tempo1*/
  if (diff2>diff1)  /*se tempo2 e' maggiore di tempo1 scrive a schermo che la ruota gira in avanti*/
  {
    Serial.println(F("la ruota gira in avanti"));
  }
  diff3 = tempo4-tempo2; /*calcola la differenza tra tempo 4 e tempo 2*/
  velocita = 212,5/diff3/100*3,6; /*calcola la velocità di movimento della ruota*/
  return(velocita); /*ritorna a void loop la velocità in km/h*/
}

int calcdist(int arr,int i) 
{
  int var0= mar_set[arr][i];
  int var1= mar_set[arr][i];
  int dist=var0-var1;
  return (dist);
}

int check_fw()
{
  unsigned long stepp[4];
  stepp[0]=millis();
  while(digitalRead(pinBUT[0])==LOW)
  {
    stepp[0]=millis();
  }
  while(digitalRead(pinBUT[0])==HIGH)
  {
    stepp[1]=millis();
  }
  while(digitalRead(pinBUT[0])==LOW)
  {
    stepp[2]=millis();
  }
  stepp[2]=stepp[2]-stepp[1];
  stepp[1]=stepp[1]-stepp[0];
  if (stepp[1]>stepp[2])
  {
    stepp[3]=1;
  }else{stepp[3]=0;};
  return (stepp[3]);
}

int check_mar()
{
  int pot[2];
  int marcia;
  pot[0] = analogRead(pinPOT[0] / rappow); /*legge il potenziometro 0, divide il valore letto e lo inserisce nell'array, il divisore è provvisorio perché non posso ancora sapere quale è la distanza percorsa dal potenziometro tra ogni rapporto.*/
  pot[1] = analogRead(pinPOT[1] / corpow); /*legge il potenziometro 0, divide il valore letto e lo inserisce nell'array, il divisore è provvisorio perché non posso ancora sapere quale è la distanza percorsa dal potenziometro tra ogni corona.*/

  if (pot[0]==1) /*identificazione marcia innestata*/
  {
    marcia=pot[1]; /*quando è innestata la 1° corona, la marcia è uguale al rapporto*/
  }
  if (pot[0]==2);
  {
    if (pot[1]==3)
    {
      marcia=6;
    }
    if (pot[1]==4)
    {
      marcia=7;
    }
    if (pot[1]==5)
    {
      marcia=8;
    }
    if (pot[1]==6)
    {
      marcia=9;
    } else {
      marce[0]==10;
    }
  }
  if (pot[0]==3)
  {
    if (pot[1]==6)
    {
      marcia=11;
    }
    if (pot[1]==7)
    {
      marcia=12;
    }
    if (pot[1]=8)
    {
      marcia==13;
    } else {
      marcia=14;
    }
  }
  return (marcia);
}

bool debounceButton_2(bool state)
{
  bool stateNow = digitalRead(pinBUT[2]);
  if(state!=stateNow)
  {
    delay(debounceMs);
    stateNow = digitalRead(pinBUT[2]);
  }
  return stateNow;
}

bool debounceButton_3(bool state)
{
  bool stateNow = digitalRead(pinBUT[3]);
  if(state!=stateNow)
  {
    delay(10);
    stateNow = digitalRead(pinBUT[3]);
  }
  return stateNow;
}